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