anchor.diff:              this = null && other = null || compare this.Head other.Head && this.Tail.IsEqual(other.Tail)
   
       member this.IsEqual (nodes : Nodes) = 
  -
           nodes.Length = this.Length 
           && let h = ref this in nodes.isForAll(fun x -> let res = compare x h.Value.Head
                                                          h := h.Value.Tail
  
positive.code:     member this.Ast = ast
  
  and VInfo<'TokenType> (vNum, statesCount) =
      let processedReductions = new ResizeArray<Reduction> ()
      let areEqualReductions (x : Reduction) (y : Reduction) = 
  //        x.prod = y.prod 
  //        && x.pos = y.pos 
  //        && x.gssVertex.State = y.gssVertex.State 
  //        && x.gssVertex.Level = y.gssVertex.Level
  //        && (x.edge.IsNone && y.edge.IsNone 
  //            || x.edge.IsSome && y.edge.IsSome
  //               && x.edge.Value.Ast = y.edge.Value.Ast
  //               && x.edge.Value.Dest.Level = y.edge.Value.Dest.Level
  //               && x.edge.Value.Dest.State = y.edge.Value.Dest.State)
          let a = x.prod = y.prod 
          let b = x.pos = y.pos 
          let c = x.gssVertex.State = y.gssVertex.State 
          let d = x.gssVertex.Level = y.gssVertex.Level
          let e = x.edge.IsNone && y.edge.IsNone 
          if not e 
          then
              let f = x.edge.IsSome && y.edge.IsSome
              if f
              then 
                  let g = x.edge.Value.Ast = y.edge.Value.Ast
                  let h = x.edge.Value.Dest.Level = y.edge.Value.Dest.Level
                  let i = x.edge.Value.Dest.State = y.edge.Value.Dest.State
                  a && b && c && d && (e || f && g && h && i)
              else 
                  false
          else 
              a && b && c && d
  
  
  
      member val vNum = vNum with get
      member val processedGssVertices = new ResizeArray<Vertex>() with get
      member val unprocessedGssVertices = new ResizeArray<Vertex>() with get
      member val reductions = new Queue<_> (10) with get
  
      member this.GetReduction() = 
          let r : Reduction = this.reductions.Dequeue()
  //        if not <| processedReductions.Any(fun x -> areEqualReductions x r)
  //        then processedReductions.Add(r)
          r
  
      member this.AddReduction(r) =
          (*if not <| processedReductions.Any(fun x -> areEqualReductions x r)
          then*) this.reductions.Enqueue(r)
  
  and [<Struct>]
      Reduction =
  
negative.code:                             for (prod, pos) in arr do
                                  currentGraphV.AddReduction(new Reduction(newVertex, prod, pos, Some edge))
                  edge.Ast
              | x -> (newVertex.Edge x).Ast 
          if ast >= 0 
          then addChildren nodes.[ast] path prod
          else 
  