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