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