anchor.diff:          new LexingFinishedArgs<'node>(treeNodes, lang, drawGraph)
   
       let processLang graph addLError addPError addSError =
  -//        let tokenize g =
  -//            try 
  -//                tokenize g
  -//                |> Some 
  -//            with
  -//            | LexerError(t,grToken) ->
  -//                (t, (grToken :?> GraphTokenValue<'br>).Edges |> Seq.nth 0 |> fun e -> e.BackRef |> getDocumentRange)
  -//                |> addLError
  -//                None
  -//        
  -//        let tokenizedGraph = tokenize graph         
  -    
  +        
           let tokenizedGraph = 
               match tokenize graph with
               | Success res -> res |> Some
               | Error errors -> 
                   errors 
  -                |> Array.map (function Smbl e -> fst e |> string, (e |> snd) |> getDocumentRange | e -> failwithf "Unexpected tocenization result: %A" e)
  +                |> Array.map 
  +                    (
  +                        function 
  +                            Smbl e -> fst e |> string, snd e |> getDocumentRange 
  +                            | e -> failwithf "Unexpected tokenization result: %A" e
  +                    )
                   |> Array.iter addLError 
                   None
   
  -        if tokenizedGraph.IsSome
  -        then 
  -            let lexFinishedArgs = prepareToTrigger tokenizedGraph.Value tokenToTreeNode 
  -            lexingFinished.Trigger(lexFinishedArgs)
  +        tokenizedGraph
  +        |> Option.iter 
  +            (
  +                fun graph -> 
  +                    let lexFinishedArgs = prepareToTrigger graph tokenToTreeNode 
  +                    lexingFinished.Trigger(lexFinishedArgs)
  +            )
   
           tokenizedGraph 
           |> Option.map
  
positive.code:             treeNode, true
          | _ -> failwith "Unexpected state in tree generation"
  
      member this.TokenToPos calculatePos (token : 'TokenType)= 
          let data (*: FSA<char*Position<'br>>*) = unbox <| tokenData token
          calculatePos data
  
      member this.GetForestWithToken range = getForestWithToken range
  
      member this.GetPairedRanges leftNumber rightNumber range toRight = 
          let tokens = new ResizeArray<_>()
          let tokToPos = this.TokenToPos calculatePos
  
          for otherTree in otherForest do
              tokens.AddRange <| otherTree.FindAllPair leftNumber rightNumber range toRight tokenToNumber tokToPos
          
          let ranges = new ResizeArray<_>()
          tokens 
          |> ResizeArray.iter (fun token -> 
              Seq.iter (fun r -> ranges.Add r) <| tokToPos token)
  
          ranges
  
      member this.TranslateToTreeNode nextTree errors = (Seq.head <| translate nextTree errors)
      
  
negative.code:         generationState
  
      let getForestWithToken range = 
  
          forest
          |> List.map
              (
                  fun (ast, errors) -> 
                      let trees = ast.GetForestWithToken range <| this.TokenToPos calculatePos
                      trees
                      |> List.map (fun tree -> this.TranslateToTreeNode tree errors)
              )
          |> List.concat
          |> ResizeArray.ofList
  
      member this.GetNextTree index =         
          let state = getNextTree 0//index
  