anchor.diff:                          print sep
                           print "%d" <| pack j gotoLists.[gotos.[i,j]]
                           print sep
  -                        let dontStackSet, stackSet = stackSets.[i,j].[0]
  -                        print "%d" <| pack stackSetLists.[dontStackSet] stackSetLists.[stackSet]
  +//                        let dontStackSet, stackSet = stackSets.[i,j].[0]
  +//                        print "%d" <| pack stackSetLists.[dontStackSet] stackSetLists.[stackSet]
                           cur <- cur + 1
                           if cur > next then
                               next <- next + 1000
  
positive.code:             |StackingConflict _-> 2*)
                          
              let gotoLists = new Dictionary<_,_>()
              let stackSetLists = new Dictionary<_,_>()
              let nextGoto, nextStackSet =
                  let numGoto = ref -1
                  let numSet = ref -1
                  (fun () -> incr numGoto; !numGoto),
                  (fun () -> incr numSet; !numSet)
              for i = 0 to statesLim do
                  for j = 0 to symbolsLim do
                      if checker gotos.[i,j] then
                          if not <| gotoLists.ContainsKey gotos.[i,j] then
                              gotoLists.Add (gotos.[i,j], nextGoto())
                          let dontStackSet, stackSet = stackSets.[i,j].[0]
                          if not <| stackSetLists.ContainsKey dontStackSet then
                                  stackSetLists.Add(dontStackSet, nextStackSet())
                          if not <| stackSetLists.ContainsKey stackSet then
                                  stackSetLists.Add(stackSet, nextStackSet())
              let gotoListsArr = Array.zeroCreate gotoLists.Count
              for v in gotoLists do
                  gotoListsArr.[v.Value] <- v.Key
              let stackSetListsArr = Array.zeroCreate stackSetLists.Count
              for v in stackSetLists do
                  stackSetListsArr.[v.Value] <- v.Key
              printInd 0 (Printf.StringFormat<_,_>(bindKW + " lists_%s = ")) name
              printArr gotoListsArr printerGotos
              printInd 0 (Printf.StringFormat<_,_>(bindKW + " %s = ")) "stackArrays"
              printArr stackSetListsArr printersStackSets
              printBrInd 0 (Printf.StringFormat<_,_>(bindKW + " %s = stackArrays |> Array.map Set.ofArray")) "stackSets"
  
              printBrInd 0 (Printf.StringFormat<_,_>(bindKW + " small_%s =")) name
  
negative.code:             let bindKW = "let private"
              
  
              let gotos = tables.gotos
  
              (*let stackLabelSign = function
              |DontStack -> 0
  