anchor.diff:              |> Seq.iter(fun edge -> processEdge edge)
               
           let concatNodes (from : InterNode<_> * InterNode<_>) (_to : InterNode<_> * InterNode<_>) = 
  -            let start, oldFinish = from
  -            let oldStart, finish = _to
  -
  -            oldStart.ReplaceMeForChildren oldFinish
  -
  -            start, finish
  +            let entry, oldExit = from
  +            let oldEntry, exit = _to
  +
  +            oldEntry.ReplaceMeForChildren oldExit
  +
  +            entry, exit
   
           let mergeNodes (nodes : (InterNode<_> * InterNode<_>) list) = 
  -            let commonStart, commonEnd = nodes.Head
  +            let commonEntry, commonExit = nodes.Head
   
               nodes
               |> List.tail
               |> List.iter 
                       (
                           fun block -> 
  -                            let oldStart, oldEnd = block
  -                            oldStart.ReplaceMeForChildren commonStart
  -                            oldEnd.ReplaceMeForParents commonEnd
  +                            let oldEntry, oldExit = block
  +                            oldEntry.ReplaceMeForChildren commonEntry
  +                            oldExit.ReplaceMeForParents commonExit
                       )
   
  -            commonStart, commonEnd
  +            commonEntry, commonExit
   
           processFirst()
           while visited.Count > 0 do
  
positive.code: 
          vertexToInterNode.[endVertex].Head
  
      let start, finish = 
          let treeRoot = 
              match tree.Root with 
              | :? AST as ast -> ast
  
negative.code:                                 processBlock child
                      )
  
          processInterNode entry []
  
          !errorList
  
      member this.Entry = entry
      member this.Exit = exit
  
      member this.FindUndefVariable() = findUndefVariable()
  
      member this.PrintToDot name = 
          let count = ref -1
          let blockToNumber = new Dictionary<_, _>()
          let interNodeToNumber = new Dictionary<_, _>()
          
          use out = new StreamWriter (name : string)
          out.WriteLine("digraph AST {")
  
          let rec printBlock (block : Block<'TokenType>) parentNumber = 
  