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