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