anchor.diff:      let parseLALR fMessage {_LALRStates = lalrStates} (pp: PostProcessor<_>) fToken (input: CharStream) =
           let fail msg: obj = (input.LastUnpinnedSpanPosition, msg) |> Message |> ParseError |> raise
           let internalError msg: obj = msg |> ParseErrorType.InternalError |> fail
  -        let getCurrentState stack =
  -            match stack with
  -            | (x, _) :: _ -> x
  -            | [] -> lalrStates.InitialState
  -        let rec impl token stack =
  +        let rec impl token currentState stack =
               let (|LALRState|) x = lalrStates.[x]
  -            let currentState = getCurrentState stack
               let nextAction =
                   match token with
                   | Some({Symbol = x}) -> currentState.Actions.TryGetValue(x)
  
positive.code:                     | Some {Symbol = term} -> ExpectedSymbol.Terminal term
                      | None -> ExpectedSymbol.EndOfInput
                  (expectedSymbols, foundToken) |> ParseErrorType.SyntaxError |> fail
          impl (fToken input) []
  
negative.code:                         | FuserNotFound -> ParseErrorType.FuserNotFound productionToReduce |> fail
                          | ex -> ParseErrorType.FuseError(productionToReduce, ex) |> fail
                      fMessage <| ParseMessage.Reduction productionToReduce
                      impl token nextState ((nextState, resultObj) :: stack)
                  | false, _ -> GotoNotFoundAfterReduction (productionToReduce, nextState) |> internalError
              | false, _ ->
                  let expectedSymbols =
  