anchor.diff:          let noiseSymbols = ImmutableArray.CreateBuilder()
           let groups = ImmutableArray.CreateBuilder()
           let groupMap = Dictionary<AbstractGroup,_>()
  +        let lineGroupsToProcess = ResizeArray()
           let productions = ImmutableArray.CreateBuilder()
           let fusers = ImmutableArray.CreateBuilder()
   
  +        let addTerminalGroup name term transformer gStart gEnd =
  +            let container = Choice1Of2 term
  +            let gStart' = GroupStart(gStart, uint32 groups.Count)
  +            addDFASymbol (Regex.string gStart) (Choice3Of4 gStart')
  +            // The end symbol might be a NewLine, so it will not be added to the DFA here.
  +            groups.Add {
  +                Name = name
  +                ContainerSymbol = container
  +                Start = gStart'
  +                End = gEnd
  +                AdvanceMode = AdvanceMode.Character
  +                // We want to keep the NewLine for the rest of the tokenizer to see.
  +                EndingMode =
  +                    match gEnd with
  +                    | Choice3Of3 _term -> EndingMode.Closed
  +                    | _newLine -> EndingMode.Open
  +                Nesting = ImmutableHashSet.Empty
  +            }
  +            terminals.Add term
  +            transformers.Add transformer
  +
           let rec getLALRSymbol (sym: Symbol) =
  -            let newTerminal name = Terminal(uint32 terminals.Count, name)
               let handleTerminal (term: AbstractTerminal) =
                   let symbol = newTerminal term.Name
                   terminalMap.Add(term, symbol)
  
positive.code:             | Symbol.LineGroup lg when groupMap.ContainsKey lg ->
                  LALRSymbol.Terminal groupMap.[lg]
              | Symbol.LineGroup lg ->
                  getNewLineTerminal()
                  |> Choice1Of3
                  |> addTerminalGroup lg.Name lg.Transformer lg.GroupStart
                  |> (fun x -> groupMap.[lg] <- x; x)
                  |> LALRSymbol.Terminal
              | Symbol.BlockGroup bg when groupMap.ContainsKey bg ->
                  LALRSymbol.Terminal groupMap.[bg]
              | Symbol.BlockGroup bg ->
                  let gEnd = GroupEnd bg.GroupEnd
                  addDFASymbol (Regex.string bg.GroupEnd) (Choice4Of4 gEnd)
                  gEnd
                  |> Choice3Of3
                  |> addTerminalGroup bg.Name bg.Transformer bg.GroupStart
                  |> (fun x -> groupMap.[bg] <- x; x)
                  |> LALRSymbol.Terminal
  
          let newLineGroupEnd =
              match newLineSymbol with
              | Choice1Of4 term -> Choice1Of3 term
              | Choice2Of4 noise -> Choice2Of3 noise
              // We will never reach that line.
              | _ -> failwith "Newline cannot be represented by something other than a terminal or a noise symbol."
  
          let handleComment comment =
              let newStartSymbol name = GroupStart(name, uint32 groups.Count)
  
negative.code:                 transformers.Add(if isNull term.Transformer then tNull else term.Transformer)
                  addDFASymbol term.Regex (Choice1Of4 symbol)
                  symbol
  
              match sym with
              | Symbol.Terminal term when terminalMap.ContainsKey(term) ->
  