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