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