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