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