anchor.diff:      /// The first control characters are included.
       let inline isASCII c = c <= char ASCIIUpperBound
   
  +    let private createJaggedArray2D length1 length2 =
  +        let arr = Array.zeroCreate length1
  +        for i = 0 to length1 - 1 do
  +            arr.[i] <- Array.zeroCreate length2
  +        arr
  +
       /// Creates a two-dimensional array of DFA state indices, whose first dimension
       /// represents the index of the current DFA state, and the second represents the
       /// ASCII character that was encountered.
       let buildDFAArray (dfa: ImmutableArray<DFAState>) =
  -        let arr = Array2D.zeroCreate dfa.Length (ASCIIUpperBound + 2)
  +        let arr = createJaggedArray2D dfa.Length (ASCIIUpperBound + 2)
           dfa
           |> Seq.iteri (fun i state ->
               let anythingElse = DFAStateTag.FromOption dfa.[i].AnythingElse
               for j = 0 to ASCIIUpperBound + 1 do
  -                Array2D.set arr i j anythingElse
  +                arr.[i].[j] <- anythingElse
               state.Edges
               |> RangeMap.toSeq
               |> Seq.takeWhile (fun x -> isASCII x.Key)
               |> Seq.iter (fun x ->
  -                Array2D.set arr i (int x.Key) (DFAStateTag.FromOption x.Value)))
  +                arr.[i].[int x.Key] <- DFAStateTag.FromOption x.Value))
           arr
   
       let buildLALRActionArray (terminals: ImmutableArray<_>) (lalr: ImmutableArray<_>) =
  
positive.code:         if state.IsError then
              DFAStateTag.Error
          elif isASCII c then
              arr.[state.Value, int c]
          else
              match RangeMap.tryFind c x.Grammar.DFAStates.[state.Value].Edges with
              | ValueSome x -> DFAStateTag.FromOption x
              | ValueNone -> arr.[state.Value, ASCIIUpperBound + 1]
      /// Gets the LALR action from the given state that corresponds to the given terminal.
      member x.GetLALRAction (Terminal (term, _)) {LALRState.Index = idx} =
          x.LALRActionArray.[int idx, int term]
      /// Gets the next LALR state according to the given state's GOTO actions.
      member x.LALRGoto (Nonterminal (nont, _)) {LALRState.Index = idx} =
          x.LALRGotoArray.[int idx, int nont]
  
negative.code: /// performed only once, at the creation of this object.
  type OptimizedOperations = private {
      Grammar: Grammar
      DFAArray: DFAStateTag [][]
      LALRActionArray: LALRAction option [][]
      LALRGotoArray: LALRState option [][]
  }
  with
      static member Create g = {
  