anchor.diff:      for i = 0 to grammar.rules.rulesCount-1 do
           rulesArr.[i] <- grammar.rules.rightSide i
   
  -    let dfaArr = Array.zeroCreate grammar.reverseRules.rulesCount
  -    for i = 0 to grammar.reverseRules.rulesCount - 1 do
  -        dfaArr.[i] <- grammar.reverseRules.dfaTable i
  +    let rulesCount = grammar.reverseRules.rulesCount
  +    let dfaTableArr = Array.zeroCreate rulesCount
  +    for i = 0 to rulesCount - 1 do
  +        dfaTableArr.[i] <- grammar.reverseRules.dfaTable i
  +    let dfaArr = dfaTableArr |> Array.map (fun x -> fst x)
  +    let dfaArrList = Array2D.create rulesCount grammar.indexator.fullCount []
  +    for i = 0 to rulesCount - 1 do
  +        for j = 0 to grammar.indexator.fullCount - 1 do
  +            for s = 0 to dfaArr.[i].Length - 1 do
  +                dfaArrList.[i, j] <- s::(dfaArr.[i].[s].[j])::dfaArrList.[i, j]
  +    let finitStatesSet = dfaTableArr |> Array.map (fun x -> snd x)
  +    
   
       let totalRulesNumberOfStates = rulesArr |> Array.sumBy (fun x -> x.numberOfStates)
       (*let rulesStart = Array.zeroCreate <| grammar.rules.rulesCount + 1
  
positive.code: 
      let statesLim = tables.gotos.GetLength 0 - 1
      let symbolsLim = tables.gotos.GetLength 1 - 1
      let statesCount = statesLim + 1
      let symbolsCount = symbolsLim + 1
      
  
negative.code:             printBrInd 2 "%s.[i].[j] <- Some (lists_%s.[x])" name name
  //            printBrInd 2 "%s.[i].[j] <- Some (lists_%s.[x], (dontStackSetNum, stackSetNum))" name name
              printBrInd 1 "cur <- cur + length * 2"
  
  
          let resultDfaArrayCreationCodePrinter name prodCount = 
              printBrInd 0 "let %s = Array.zeroCreate %d" name prodCount
              printBrInd 0 "for i = 0 to %d do" (prodCount - 1)
              printBrInd 2 "%s.[i] <- Array.zeroCreate %d" name symbolsCount
              printBrInd 0 "cur <- 0"
              printBrInd 0 "while cur < small_%s.Length do" name
              printBrInd 1 "let i = small_%s.[cur] >>> 16" name
              printBrInd 1 "let length = small_%s.[cur] &&& %d" name andNum
              printBrInd 1 "cur <- cur + 1"
              printBrInd 1 "for k = 0 to length-1 do"
              printBrInd 2 "let j = small_%s.[cur + k] >>> 16" name
              printBrInd 2 "let x = small_%s.[cur + k] &&& %d" name andNum
              printBrInd 2 "%s.[i].[j] <- lists_%s.[x]" name name
              printBrInd 1 "cur <- cur + length"
                  
          let printGotoArrList() =
              // although we have lists of gotos and stacLabels, only first elements of these lists are really processed
  