anchor.diff:  
                   let! tableCounts = getSingleElement 't'B readTableCounts records
   
  -                let! charSets = assignIndexedElements 'c'B readCharSet tableCounts.CharSetTables records
  +                let! charSets = getIndexedElements 'c'B readCharSet tableCounts.CharSetTables records
                   let fCharSet = uint32 >> SafeArray.getUnsafe charSets
   
  -                let! symbols = assignIndexedElements 'S'B readSymbol tableCounts.SymbolTables records
  +                let! symbols = getIndexedElements 'S'B readSymbol tableCounts.SymbolTables records
                   let fSymbol = uint32 >> SafeArray.getUnsafe symbols
   
                   let fGroup = Indexed.createWithKnownLength16 tableCounts.GroupTables
  -                let! groups = assignIndexedElements 'g'B (readGroup fSymbol fGroup) tableCounts.GroupTables records
  -
  -                let! productions = assignIndexedElements 'R'B (readProduction fSymbol) tableCounts.ProductionTables records
  +                let! groups = getIndexedElements 'g'B (readGroup fSymbol fGroup) tableCounts.GroupTables records
  +
  +                let! productions = getIndexedElements 'R'B (readProduction fSymbol) tableCounts.ProductionTables records
                   let fProduction = uint32 >> SafeArray.getUnsafe productions
   
                   let fDFA = Indexed.createWithKnownLength16 tableCounts.DFATables
                   let fLALR = Indexed.createWithKnownLength16 tableCounts.LALRTables
                   let! initialDFA, initialLALR = getSingleElement 'I'B (readInitialStates fDFA fLALR) records
   
  -                let! dfaStates = assignIndexedElements 'D'B (readDFAState fCharSet fSymbol fDFA) tableCounts.DFATables records
  +                let! dfaStates = getIndexedElements 'D'B (readDFAState fCharSet fSymbol fDFA) tableCounts.DFATables records
                   let dfaStateTable = {InitialState = dfaStates.Item initialDFA; States = dfaStates}
   
  -                let! lalrStates = assignIndexedElements 'L'B (readLALRState fSymbol fProduction fLALR) tableCounts.LALRTables records
  +                let! lalrStates = getIndexedElements 'L'B (readLALRState fSymbol fProduction fLALR) tableCounts.LALRTables records
                   let lalrStateTable = {InitialState = lalrStates.Item initialLALR; States = lalrStates}
   
                   return GOLDGrammar.create properties symbols charSets productions dfaStateTable lalrStateTable groups
  
positive.code: 
          let readGroup fSymbol fGroup index =
              let readNestedGroups =
                  (function | UInt16 x :: xs -> x |> fGroup |> Option.map (fun x -> x, xs) | _ -> None)
                  |> readToEnd true
                  >> Option.map set
              function
              | String name :: UInt16 containerIndex :: UInt16 startIndex :: UInt16 endIndex :: UInt16 advanceMode :: UInt16 endingMode :: Empty :: UInt16 _nestingCount :: xs -> maybe {
  
negative.code:                 | UInt16 symbolIndex :: xs -> maybe {
                      let! symbol = fSymbol symbolIndex
                      match xs with
                      | [UInt16 1us; UInt16 targetStateIndex; Empty] ->
                          let! targetState = fLALR targetStateIndex
                          return symbol, Shift targetState
                      | [UInt16 2us; UInt16 targetProductionIndex; Empty] ->
                          let! targetProduction = fProduction targetProductionIndex
                          return symbol, Reduce targetProduction
                      | [UInt16 3us; UInt16 targetStateIndex; Empty] ->
                          let! targetState = fLALR targetStateIndex
                          return symbol, Goto targetState
                      | [UInt16 4us; UInt16 _; Empty] -> return symbol, Accept
                      | _ -> return! None
                      }
                  | _ -> None
                  |> readToEnd false 4
                  >> Option.map Map.ofSeq
              function
              | Empty :: xs -> readLALRAction xs |> Option.map (fun actions -> {Index = index; Actions = actions})
  