          self.bacov[orth.last3] = last3
          self.bacov[orth.norm] = norm
          self.bacov[orth.shape] = shape
  
          self.ortho.set(lex, <size_t>orth)
          return orth
  
      cdef Distribution* new_dist(self, unicode lex) except NULL:
          dist = <Distribution*>calloc(1, sizeof(Distribution))
          self.distri.set(lex, <size_t>dist)
 
</s> remove         self.distri.set(lex, <size_t>dist)
 </s> add  </s> remove         self.bacov[word.sic] = key
        word.orth = self.lookup_orth(string)
        word.dist = self.lookup_dist(string)
        self.vocab.set(key, <size_t>word)
 </s> add         word.orth = self.new_orth(string)
        word.dist = self.new_dist(string)
        self.vocab[word.lex] = <size_t>word </s> remove     cdef Lexeme_addr lookup(self, unicode string) except 0:
        cdef size_t length = len(string)
        if length == 0:
            return <Lexeme_addr>&BLANK_WORD

        cdef StringHash hashed = hash(string)
        # First, check words seen 2+ times
        cdef Lexeme* word_ptr = <Lexeme*>self.vocab.get(string)
        if word_ptr == NULL:
            word_ptr = self.new_lexeme(string, string)
        return <Lexeme_addr>word_ptr

    cdef Lexeme_addr lookup_chunk(self, unicode string) except 0:
        '''Fetch a Lexeme representing a word string. If the word has not been seen,
        construct one, splitting off any attached punctuation or clitics.  A
        reference to BLANK_WORD is returned for the empty string.
        '''
        cdef size_t length = len(string)
        if length == 0:
            return <Lexeme_addr>&BLANK_WORD
        # First, check words seen 2+ times
        cdef Lexeme* word_ptr = <Lexeme*>self.vocab.get(string)
        cdef int split
        if word_ptr == NULL:
            split = self.find_split(string, length)
            if split != 0 and split != -1 and split < length:
                word_ptr = self.new_lexeme(string, string[:split])
                word_ptr.tail = <Lexeme*>self.lookup_chunk(string[split:])
            else:
                word_ptr = self.new_lexeme(string, string)
        return <Lexeme_addr>word_ptr

    cdef Orthography* lookup_orth(self, unicode lex):
        cdef Orthography* orth = <Orthography*>self.ortho.get(lex)
        if orth == NULL:
            orth = self.new_orth(lex)
        return orth

    cdef Distribution* lookup_dist(self, unicode lex):
        cdef Distribution* dist = <Distribution*>self.distri.get(lex)
        if dist == NULL:
            dist = self.new_dist(lex)
        return dist
 </s> add     cdef Lexeme* lookup(self, unicode string) except NULL:
        if len(string) == 0:
            return &BLANK_WORD
        cdef Lexeme* word = <Lexeme*>self.vocab[hash(string)]
        if word == NULL:
            word = self.new_lexeme(string)
        return word </s> remove     cdef Lexeme* new_lexeme(self, unicode key, unicode string) except NULL:
 </s> add     cdef Lexeme** lookup_chunk(self, unicode string) except NULL:
        assert len(string) != 0
        cdef Lexeme** chunk = <Lexeme**>self.chunks[hash(string)]
        cdef int split
        if chunk == NULL:
            chunk = self.new_chunk(string, self.find_substrings(string))
        return chunk

    cdef Lexeme** new_chunk(self, unicode string, list substrings) except NULL:
        cdef Lexeme** chunk = <Lexeme**>calloc(len(substrings) + 1, sizeof(Lexeme*))
        for i, substring in enumerate(substrings):
            chunk[i] = self.lookup(substring)
        chunk[i + 1] = NULL
        self.chunks[hash(string)] = <size_t>chunk
        return chunk

    cdef Lexeme* new_lexeme(self, unicode string) except NULL: </s> remove         word.sic = hash(key)
 </s> add 
          self.bacov[orth.last3] = last3
          self.bacov[orth.norm] = norm
          self.bacov[orth.shape] = shape
  

          return orth
  
      cdef Distribution* new_dist(self, unicode lex) except NULL:
          dist = <Distribution*>calloc(1, sizeof(Distribution))
          self.distri.set(lex, <size_t>dist)
keep keep keep keep replace keep keep keep keep keep
 * Refactor spacy so that chunks return arrays of lexemes, so that there is properly one lexeme per word. 
spacy/spacy.pyx