anchor.diff:                      | CannotChoose reason ->
                           LALRConflict.Create index sym existingAction action reason
                           |> BuildError.LALRConflict
  -                        |> conflicts.Add
  +                        |> errors.Add
                   | false, _ -> b.Add(term, action)
  +            let addActionConflicted k v =
  +                match bConflicted.TryGetValue(k) with
  +                | true, vs -> bConflicted.[k] <- v :: vs
  +                | false, _ -> bConflicted.[k] <- [v]
               for item in itemSet.Goto do
                   match item with
                   | KeyValue(LALRSymbol.Terminal term, stateToShiftTo) ->
  -                    addAction term (LALRAction.Shift(uint32 stateToShiftTo))
  +                    let action = LALRAction.Shift(uint32 stateToShiftTo)
  +                    addAction term action
  +                    addActionConflicted term action
                   | _ -> ()
               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
  +                    let term = firstSets.AllTerminals.[idx]
  +                    let action = LALRAction.Reduce item.Item.Production
  +                    addAction term action
  +                    addActionConflicted term action
  +            b.ToImmutable(), bConflicted.ToImmutable()
  +        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
  +                    |> errors.Add
  +                    resolveEOFConflict xs
  +        let eofActions =
               closedItem
               |> Seq.choose (fun item ->
                   if item.Lookahead.HasEnd then
  
positive.code:     let firstSets = computeFirstSetMap ct terminals nonterminals productions
      let lookaheads = computeLookaheadItems ct fGetAllProductions firstSets kernelItems
  
      let conflicts = ResizeArray()
      let resolveConflict term x1 x2 =
          match x1, x2, term with
          | LALRAction.Shift _, LALRAction.Reduce prod, Some term ->
  
negative.code:                 | _ -> None
              )
              |> ImmutableDictionary.CreateRange
          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
  