Insert a list of given cards into the stack at a given indice.

        :arg list cards:
            The list of cards to insert into the stack.
        :arg int indice:
            Where to insert the given cards.
557894
def insert_list(self, cards, indice=-1):
        
        self_size = len(self.cards)

        if indice in [0, -1]:
            if indice == -1:
                self.cards += cards
            else:
                self.cards.extendleft(cards)
        elif indice != self_size:
            half_x, half_y = self.split(indice)
            self.cards = list(half_x.cards) + list(cards) + list(half_y.cards)
1306406
def insert(self, index, chord):
        
        self._chords.insert(index, as_chord(chord))
158512
def insert(self, index, x):
        
        self.real_list.insert(index, x)
        self.observer(UpdateType.CREATED, x, index)
316249
def insert(self, revision, index):
        
        if not isinstance(revision, Revision):
            raise InvalidArgType()

        for rev in self.revisions:
            if rev == revision:
                return self

        self.revisions.insert(index, revision)

        return self
846222
def insert(self, var, value, index=None):
        
        current = self.__get(var)
        if not isinstance(current, list):
            raise KeyError("%s: is not a list" % var)
        if index is None:
            current.append(value)
        else:
            current.insert(index, value)
        if self.auto_save:
            self.save()
1053631
def add_int(self, n):
        
        self.packet.write(struct.pack('>I', n))
        return self
1164993
def add_row(self, array):
        

        self._check_row_size(array)
        self._rows.append(map(str, array))
363549
def insert(self, loc, item, value, allow_duplicates=False):
        
        if not allow_duplicates and item in self.items:
            # Should this be a different kind of error??
            raise ValueError('cannot insert {}, already exists'.format(item))

        if not isinstance(loc, int):
            raise TypeError("loc must be int")

        # insert to the axis; this could possibly raise a TypeError
        new_axis = self.items.insert(loc, item)

        block = make_block(values=value, ndim=self.ndim,
                           placement=slice(loc, loc + 1))

        for blkno, count in _fast_count_smallints(self._blknos[loc:]):
            blk = self.blocks[blkno]
            if count == len(blk.mgr_locs):
                blk.mgr_locs = blk.mgr_locs.add(1)
            else:
                new_mgr_locs = blk.mgr_locs.as_array.copy()
                new_mgr_locs[new_mgr_locs >= loc] += 1
                blk.mgr_locs = new_mgr_locs

        if loc == self._blklocs.shape[0]:
            # np.append is a lot faster, let's use it if we can.
            self._blklocs = np.append(self._blklocs, 0)
            self._blknos = np.append(self._blknos, len(self.blocks))
        else:
            self._blklocs = np.insert(self._blklocs, loc, 0)
            self._blknos = np.insert(self._blknos, loc, len(self.blocks))

        self.axes[0] = new_axis
        self.blocks += (block,)
        self._shape = None

        self._known_consolidated = False

        if len(self.blocks) > 100:
            self._consolidate_inplace()
768664
def insert_io( args ):
    
    global CACHE_
    load_cache()
    hash = args['hash']
    record_used('cache', hash)
    packet_num = args['packet_num']
    if hash not in CACHE_['cache']:
        CACHE_['cache'][hash] = {}
    CACHE_['cache'][hash][packet_num] = pickle.dumps(args, PPROT)
    write_out()
900798
def add(self,dimlist,dimvalues):
        '''
        
        '''
        for i,d in enumerate(dimlist):
            self[d] = dimvalues[i]
        
        self.set_ndims()
549772
def insert(self, position, item, select=False):
        
        if item in self:
            raise ValueError("item %s already in list" % item)
        modeliter = self.model.insert(position, (item,))
        self._id_to_iter[id(item)] = modeliter
        if select:
            self.selected_item = item
        self.emit('item-inserted', item, position)
1228206
def _insert_row(self, i, index):
        
        if i == len(self._index):
            self._add_row(index)
        else:
            self._index.insert(i, index)
            for c in range(len(self._columns)):
                self._data[c].insert(i, None)
1041515
def _insert(self, key, records, count):
        
        if key not in self.records:
            assert key not in self.counts
            self.records[key] = records
            self.counts[key] = count
        else:
            self.records[key] = np.vstack((self.records[key], records))
            assert key in self.counts
            self.counts[key] += count
218376
def insert(self, loc, column, value, allow_duplicates=False,
               inplace=False):
        
        out = self if inplace else self.copy()
        out._frame.insert(loc, column, value,
                          allow_duplicates=allow_duplicates)
        if not inplace:
            return out
118708
static private <T>  void fillList(final int listsToAdd, Stack<List<T>> reusableLists, List<List<T>> aSplit)
    {
        for(int j = 0; j < listsToAdd; j++)
            if(reusableLists.isEmpty())
                aSplit.add(new ArrayList<>());
            else
                aSplit.add(reusableLists.pop());
    }
451546
def insert(self, i, v):
        """"""
        self.list1.insert(i, v)
        self.list2.insert(i, v.obj)
        if isinstance(v, EpBunch):
            v.theidf = self.theidf
948420
def insert(index, *items)
      inserting(index ... index + items.size) do
        @array.insert(index, *items)
      end
      self
    end