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