anchor.diff:                      vertexDestReverse.addEdge(new Edge<_,_>(currentReverseState, labelEdge))
                       if not (processedVertex.Contains(vertexDest.label))
                       then
  -                        buildReverseStateVertex vertexDest vertexDestReverse firstReverseState processedVertex
  +                        buildReverseStateVertex vertexDest vertexDestReverse arrayWithFirstState processedVertex
               let rec setReverseStateLabels (currentState : Vertex<_,_>) (stateToReverseVertex : ResizeArray<Vertex<_,_>>) =
                   currentState.setLabel(nextReverseStateNumber)
                   stateToReverseVertex.Add(currentState)
  
positive.code:             let nextReverseStateNumber =
                  incr number
                  !number
              let rec buildReverseStateVertex (currentState : Vertex<_,_>) (currentReverseState : Vertex<_,_>) (firstReverseState : Vertex<_,_>) (processedVertex : HashSet<_>) =
                  processedVertex.Add(currentState.label) |> ignore
                  let currentEdges = currentState.outEdges
                  if currentEdges.Count = 0
                  then
                      firstReverseState = currentReverseState |> ignore
                  for edge in currentEdges do
                      let vertexDest = edge.dest
                      let labelEdge = edge.label
  
negative.code:             let stateToReverseVertex = new ResizeArray<Vertex<_,_>>()
              let firstState = nfaProduction.startState
              let lastReverseState = new Vertex<_,_>(firstState.label)
              let arrayWithFirstReverseState = new ResizeArray<_>()
              let setOfLabels = new HashSet<_>()
              buildReverseStateVertex firstState lastReverseState arrayWithFirstReverseState setOfLabels
              let firstReverseState = arrayWithFirstReverseState.[0]
              setReverseStateLabels firstReverseState stateToReverseVertex
              let prodReverse : NFAProduction.t = {numberOfStates = nfaProduction.numberOfStates; startState = firstReverseState; stateToVertex = stateToReverseVertex |> Seq.toArray}
              prodReverse
  
          Array.map (fun i -> rules.rightSide i |> reverseNFA) [|0..rules.rulesCount - 1|]
              
      let symbolAndNextPos =
          let result : (int * int) [][] = Array.zeroCreate rules.rulesCount
  