anchor.diff:  
           let readProduction fSymbol index =
               let readChildrenSymbols =
  -                (function | UInt16 x :: xs -> x |> fSymbol |> Option.map (fun x -> x, xs) | _ -> None)
  -                |> readToEnd true
  +                (List.exactlyOne >> wantUInt16 >> Option.bind fSymbol)
  +                |> readToEnd true 1
               function
               | UInt16 headIndex :: Empty :: xs -> maybe {
                   let! headSymbol = fSymbol headIndex
  
positive.code: 
      module private Implementation =
  
          let consMaybe x xs = Option.map (List.cons x) xs
  
          let readToEnd allowEmpty fReadIt x =
              let rec impl x =
                  match fReadIt x with
                  | None -> None
                  | Some (x, []) -> Some [x]
                  | Some (x, xs) -> consMaybe x (impl xs)
              match x with
              | [] when allowEmpty -> Some []
              | x -> impl x
  
          let readProperty =
              function
  
negative.code: 
                  let! tableCounts = getSingleElement 't'B readTableCounts records
  
                  let! charSets = getIndexedElements 'c'B readCharSet tableCounts.CharSetTables records
                  let fCharSet = uint32 >> SafeArray.getUnsafe charSets
  
                  let! symbols = getIndexedElements 'S'B readSymbol tableCounts.SymbolTables records
                  let fSymbol = uint32 >> SafeArray.getUnsafe symbols
  
                  let fGroup = Indexed.createWithKnownLength16 tableCounts.GroupTables
                  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 = getIndexedElements 'D'B (readDFAState fCharSet fSymbol fDFA) tableCounts.DFATables records
                  let dfaStateTable = {InitialState = dfaStates.Item initialDFA; States = dfaStates}
  
                  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
  