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