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