anchor.diff:  [<Struct>]
   type StateInfo<'a, 'br> =
       val StartV: int
  -    val AccumulatedString: ResizeArray<'a>
  -    val Positions: ResizeArray<Position<'br>>
  +    val AccumulatedString: list<'a> 
  +    val Positions: list<Position<'br>>
       new (startV, str, positions) = {StartV = startV; AccumulatedString = str; Positions = positions}
   
   [<Struct>]
  
positive.code:         res
  
      static member Create(trans, accept) = new UnicodeTables(trans, accept)
  
  //    let query = "select \" f , " + (if x < 2 then "x" else "y") + "from z"
  //    let DB = new MS_DB("")
  //    let res = DB.exec query
  //    res |> Seq.iter (printfn "%A")
negative.code:     let tokenize actions (lexbuf:LexBuffer<_,_>) printG =
          //let edgesSeq = edgesSeq |> Array.ofSeq
          let add (edg:LexerEdge<_,_>) (newStt:State<_,_>) =
              let x = 
                  lexbuf.States.[edg.Target]
                  |> ResizeArray.tryFind 
                      (fun (x:State<_,_>) -> x.AcceptAction = newStt.AcceptAction && x.StateID = newStt.StateID)
              match x with
              | Some x ->
                  newStt.Info
                  |> ResizeArray.iter(
                      fun i -> 
                          if x.Info.Exists(fun j -> j.StartV = i.StartV
                                                    && i.AccumulatedString.Length = j.AccumulatedString.Length
                                                    && List.forall2 (=) i.AccumulatedString j.AccumulatedString) 
                             |> not
                          then x.Info.Add i)
              | None -> lexbuf.States.[edg.Target].Add newStt
  