anchor.diff:                  | _ -> None
               )
               |> ImmutableDictionary.CreateRange
  -        let actions =
  +        let struct(actions, actionsConflicted) =
               let b = ImmutableDictionary.CreateBuilder()
  +            let bConflicted = ImmutableDictionary.CreateBuilder()
               let mutable hasChosenNeither = false
               let addAction term action =
                   match b.TryGetValue(term) with
  
positive.code:                     | CannotChoose reason ->
                          LALRConflict.Create index sym existingAction action reason
                          |> BuildError.LALRConflict
                          |> conflicts.Add
                  | false, _ -> b.Add(term, action)
              for item in itemSet.Goto do
                  match item with
                  | KeyValue(LALRSymbol.Terminal term, stateToShiftTo) ->
                      addAction term (LALRAction.Shift(uint32 stateToShiftTo))
                  | _ -> ()
              for item in closedItem do
                  for idx in item.Lookahead do
                      addAction firstSets.AllTerminals.[idx] (LALRAction.Reduce item.Item.Production)
              b.ToImmutable()
          let eofAction =
              let rec resolveEOFConflict =
                  function
                  | [] -> None
                  | [x] -> Some x
                  | x1 :: x2 :: xs ->
                      match fResolveConflict None x1 x2 with
                      | ChooseOption1 -> resolveEOFConflict (x1 :: xs)
                      | ChooseOption2 -> resolveEOFConflict (x2 :: xs)
                      | ChooseNeither -> resolveEOFConflict xs
                      | CannotChoose reason ->
                          LALRConflict.Create index None x1 x2 reason
                          |> BuildError.LALRConflict
                          |> conflicts.Add
                          resolveEOFConflict xs
              closedItem
              |> Seq.choose (fun item ->
                  if item.Lookahead.HasEnd then
  
negative.code:     lookaheads
  
  /// Creates an LALR state table.
  let private createLALRStates (ct: CancellationToken) fGetAllProductions (firstSets: FirstSets) fResolveConflict errors startSymbol itemSets (lookaheadTables: LookaheadItemsTable) =
      IA itemSets
      RA errors
  
      let emptyLookahead = LookaheadSet(firstSets.AllTerminals.Length)
      emptyLookahead.Freeze()
      let states = ImmutableArray.CreateBuilder itemSets.Length
      let statesConflicted = ImmutableArray.CreateBuilder itemSets.Length
      for itemSet in itemSets do
          ct.ThrowIfCancellationRequested()
          let index = uint32 itemSet.Index
  