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