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