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