          self.mem = Pool()
          # Guarantee self.lex[i-x], for any i >= 0 and x < padding is in bounds
          # However, we need to remember the true starting places, so that we can
          # realloc.
          self._lex_ptr = <const Lexeme**>self.mem.alloc(size + (PADDING*2), sizeof(Lexeme*))
          self._idx_ptr = <int*>self.mem.alloc(size + (PADDING*2), sizeof(int))
          self._pos_ptr = <int*>self.mem.alloc(size + (PADDING*2), sizeof(int))
          self._ner_ptr = <int*>self.mem.alloc(size + (PADDING*2), sizeof(int))
          self.lex = self._lex_ptr
          self.idx = self._idx_ptr
          self.pos = self._pos_ptr
          self.ner = self._ner_ptr
          cdef int i
          for i in range(size + (PADDING*2)):
              self.lex[i] = &EMPTY_LEXEME
          self.lex += PADDING
          self.idx += PADDING
 
</s> remove         self._lex_ptr = <const Lexeme**>self.mem.realloc(self._lex_ptr, n * sizeof(Lexeme*))
        self._idx_ptr = <int*>self.mem.realloc(self._idx_ptr, n * sizeof(int))
        self._pos_ptr = <int*>self.mem.realloc(self._pos_ptr, n * sizeof(int))
        self._ner_ptr = <int*>self.mem.realloc(self._ner_ptr, n * sizeof(int))
        self.lex = self._lex_ptr + PADDING
        self.idx = self._idx_ptr + PADDING
        self.pos = self._pos_ptr + PADDING
        self.ner = self._ner_ptr + PADDING
 </s> add         self._data = <TokenC*>self.mem.realloc(self._data, n * sizeof(TokenC))
        self.data = self._data + PADDING
        cdef int i </s> remove             self.lex[i] = &EMPTY_LEXEME
        self.lex += PADDING
        self.idx += PADDING
        self.pos += PADDING
        self.ner += PADDING
 </s> add             self._data[i] = EMPTY_TOKEN
        self.data = self._data + PADDING </s> remove             if tokens[i].id == 1:
 </s> add             if tokens[i].lex.id == 1: </s> remove             lexemes[i] = tokens[i]
 </s> add             lexemes[i] = tokens[i].lex </s> remove         '''Retrieve a pointer to a Lexeme from the lexicon.'''
 </s> add         '''Get a pointer to a Lexeme from the lexicon, creating a new Lexeme
        if necessary, using memory acquired from the given pool.  If the pool
        is the lexicon's own memory, the lexeme is saved in the lexicon.'''
        self._data = <TokenC*>self.mem.alloc(size + (PADDING*2), sizeof(TokenC))
          self.mem = Pool()
          # Guarantee self.lex[i-x], for any i >= 0 and x < padding is in bounds
          # However, we need to remember the true starting places, so that we can
          # realloc.
        self._data = <TokenC*>self.mem.alloc(size + (PADDING*2), sizeof(TokenC))
        self._data = <TokenC*>self.mem.alloc(size + (PADDING*2), sizeof(TokenC))
        self._data = <TokenC*>self.mem.alloc(size + (PADDING*2), sizeof(TokenC))
        self._data = <TokenC*>self.mem.alloc(size + (PADDING*2), sizeof(TokenC))
        self._data = <TokenC*>self.mem.alloc(size + (PADDING*2), sizeof(TokenC))
        self._data = <TokenC*>self.mem.alloc(size + (PADDING*2), sizeof(TokenC))
        self._data = <TokenC*>self.mem.alloc(size + (PADDING*2), sizeof(TokenC))
        self._data = <TokenC*>self.mem.alloc(size + (PADDING*2), sizeof(TokenC))
          cdef int i
          for i in range(size + (PADDING*2)):
              self.lex[i] = &EMPTY_LEXEME
          self.lex += PADDING
          self.idx += PADDING
keep keep keep keep replace replace replace replace replace replace replace replace keep keep keep keep keep
 * Introduce a TokenC struct, to handle token indices, pos tags and sense tags 
spacy/tokens.pyx