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