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