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