              cdef const TokenC* ptr = self.c + (self.c.r_edge - self.i)
              tokens = []
              cdef int nr_iter = 0
              while ptr > self.c:
                  # If this head is still to the right of us, we can skip to it
                  # No token that's between this token and this head could be our
                  # child.
                  if (ptr.head < 0) and ((ptr + ptr.head) > self.c):
                      ptr += ptr.head
                  elif ptr + ptr.head == self.c:
                      tokens.append(self.doc[ptr - (self.c - self.i)])
                      ptr -= 1
                  else:
                      ptr -= 1
                  if nr_iter >= 10000000:
 
</s> remove                 # If this head is still to the right of us, we can skip to it
                # No token that's between this token and this head could be our
                # child.
                if (ptr.head >= 1) and (ptr + ptr.head) < self.c:
                    ptr += ptr.head

                elif ptr + ptr.head == self.c:
 </s> add                 if ptr + ptr.head == self.c: </s> remove                     ptr -= 1
                else:
                    ptr -= 1
 </s> add                 ptr -= 1
                nr_iter += 1 </s> remove                     ptr += 1
                else:
                    ptr += 1
 </s> add                 ptr += 1 </s> remove         smallest_np_arc = self._get_smallest_nonproj_arc(proj_heads)
 </s> add         smallest_np_arc = cls._get_smallest_nonproj_arc(proj_heads) </s> remove         for heads,labels in labeled_trees:
            proj_heads,deco_labels = self.projectivize(heads,labels)
            # set the label to ROOT for each root dependent
            deco_labels = [ 'ROOT' if head == i else deco_labels[i] for i,head in enumerate(proj_heads) ]
            preprocessed.append((proj_heads,deco_labels))
 </s> add         freqs = Counter()
        for raw_text, sents in gold_tuples:
            prepro_sents = []
            for (ids, words, tags, heads, labels, iob), ctnts in sents:
                proj_heads,deco_labels = cls.projectivize(heads,labels)
                # set the label to ROOT for each root dependent
                deco_labels = [ 'ROOT' if head == i else deco_labels[i] for i,head in enumerate(proj_heads) ]
                # count label frequencies
                if label_freq_cutoff > 0:
                    freqs.update( label for label in deco_labels if cls.is_decorated(label) )
                prepro_sents.append(((ids,words,tags,proj_heads,deco_labels,iob), ctnts))
            preprocessed.append((raw_text, prepro_sents))
                if ptr + ptr.head == self.c:
              cdef const TokenC* ptr = self.c + (self.c.r_edge - self.i)
              tokens = []
              cdef int nr_iter = 0
              while ptr > self.c:
                if ptr + ptr.head == self.c:
                if ptr + ptr.head == self.c:
                if ptr + ptr.head == self.c:
                if ptr + ptr.head == self.c:
                if ptr + ptr.head == self.c:
                if ptr + ptr.head == self.c:
                      tokens.append(self.doc[ptr - (self.c - self.i)])
                      ptr -= 1
                  else:
                      ptr -= 1
                  if nr_iter >= 10000000:
keep keep keep keep replace replace replace replace replace replace keep keep keep keep keep
 integrated pseudo-projective parsing into parser

- nonproj.pyx holds a class PseudoProjectivity which currently holds
  all functionality to implement Nivre & Nilsson 2005's pseudo-projective
  parsing using the HEAD decoration scheme
- changed lefts/rights in Token to account for possible non-projective
  structures 
spacy/tokens/token.pyx