anchor.diff:              let bindKW = "let private"
               
   
  -            let unzipArr = tables.gotos |> Array2D.map List.unzip
  -            let gotos = unzipArr |> Array2D.map fst
  -            let stackSets = unzipArr |> Array2D.map snd
  +            let gotos = tables.gotos
   
               (*let stackLabelSign = function
               |DontStack -> 0
  
positive.code:             printBrInd 2 "let j = small_%s.[cur + k*2] >>> 16" name
              printBrInd 2 "let x = small_%s.[cur + k*2] &&& %d" name andNum
              
              printBrInd 2 "let dontStackSetNum = small_%s.[cur + k*2 + 1] >>> 16" name
              printBrInd 2 "let stackSetNum = small_%s.[cur + k*2 + 1] &&& %d" name andNum
  
              printBrInd 2 "%s.[i].[j] <- Some (lists_%s.[x], (dontStackSetNum, stackSetNum))" name name
              printBrInd 1 "cur <- cur + length * 2"
                  
          let printGotoArrList() =
              // although we have lists of gotos and stacLabels, only first elements of these lists are really processed
              let checker = fun (x : _ list ) -> not x.IsEmpty
              let printerGotos = fun (x : _ list ) -> print "%d" x.[0]
              let printersStackSets = fun x -> printSetAsArray x (fun y -> print "%d" y)
              let name = "gotos"
              let lBr : Printf.StringFormat<_,_> =  "[|"
              let rBr : Printf.StringFormat<_,_> =  "|]"
  
negative.code:     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 totalRulesNumberOfStates = rulesArr |> Array.sumBy (fun x -> x.numberOfStates)
      (*let rulesStart = Array.zeroCreate <| grammar.rules.rulesCount + 1
      let mutable cur = 0
  