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