<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def insert(self, index, *intvs):
 """Return a copy with ``intvs`` inserted before ``index``. The given interval products are inserted (as a block) into ``self``, yielding a new interval product whose number of dimensions is the sum of the numbers of dimensions of all involved interval products. Note that no changes are made in-place. Parameters index : int Index of the dimension before which ``other`` is to be inserted. Must fulfill ``-ndim <= index <= ndim``. Negative indices count backwards from ``self.ndim``. Interval products to be inserted into ``self``. Returns ------- newintvp : `IntervalProd` The enlarged interval product. Examples -------- IntervalProd([ 0., -1., 2.], [ 1. , -0.5, 3. ]) IntervalProd([-1., 0., 2.], [-0.5, 1. , 3. ]) IntervalProd([-1., 0., 0., 2.], [-0.5, 1. , 1. , 3. ]) """

        index, index_in = safe_int_conv(index), index

        if not -self.ndim <= index <= self.ndim:
            raise IndexError('index {0} outside the valid range -{1} ... {1}'
                             ''.format(index_in, self.ndim))
        if index < 0:
            index += self.ndim

        if len(intvs) == 0:
            # Copy of `self`
            return IntervalProd(self.min_pt, self.max_pt)

        elif len(intvs) == 1:
            # Insert single interval product
            intv = intvs[0]
            if not isinstance(intv, IntervalProd):
                raise TypeError('{!r} is not a `IntervalProd` instance'
                                ''.format(intv))
            new_min_pt = np.empty(self.ndim + intv.ndim)
            new_max_pt = np.empty(self.ndim + intv.ndim)

            new_min_pt[: index] = self.min_pt[: index]
            new_max_pt[: index] = self.max_pt[: index]
            new_min_pt[index: index + intv.ndim] = intv.min_pt
            new_max_pt[index: index + intv.ndim] = intv.max_pt
            if index < self.ndim:  # Avoid IndexError
                new_min_pt[index + intv.ndim:] = self.min_pt[index:]
                new_max_pt[index + intv.ndim:] = self.max_pt[index:]

            return IntervalProd(new_min_pt, new_max_pt)

        else:
            # Recursively insert one, then rest into the result
            return self.insert(index, intvs[0]).insert(
                index + intvs[0].ndim, *(intvs[1:]))