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