anchor.diff:          let hashTerminalSet = LookaheadSet firstSets.AllTerminals.Length
           hashTerminalSet.HasHash <- true
           hashTerminalSet.Freeze()
  -        itemSets
  -        |> Seq.iter (fun itemSet ->
  -            itemSet.Kernel
  -            |> Set.iter (fun item ->
  +        for itemSet in itemSets do
  +            for item in itemSet.Kernel do
                   let closure = closure1 fGetAllProductions firstSets [item, hashTerminalSet]
  -                closure
  -                |> List.iter (fun {Item = closureItem; Lookahead = la} ->
  +                for {Item = closureItem; Lookahead = la} in closure do
                       if not closureItem.IsAtEnd then
                           match itemSet.Goto.TryGetValue(closureItem.CurrentSymbol) with
                           | true, gotoIdx ->
  
positive.code:                 | true, existingAction ->
                      b.[term] <- fResolveConflict index (Some term) existingAction action
                  | false, _ -> b.Add(term, action)
              itemSet.Goto
              |> Seq.iter (function
                  | KeyValue(LALRSymbol.Terminal term, stateToShiftTo) ->
                      addAction term (LALRAction.Shift(uint32 stateToShiftTo))
                  | _ -> ()
              )
              closedItem
              |> List.iter (fun item ->
                  for idx in item.Lookahead do
                      addAction firstSets.AllTerminals.[idx] (LALRAction.Reduce item.Item.Production)
              )
              b.ToImmutable()
          let eofAction =
              let rec resolveEOFConflict =
  
negative.code:         | LALRSymbol.Terminal _ -> false
          | LALRSymbol.Nonterminal nont -> dict.HasEmpty nont
  
      for {Head = x; Handle = xs} in productions do
          if xs.IsEmpty then
              dict.AddEmpty x |> ignore
  
      let mutable changed = true
  
  