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