anchor.diff:                  }
               | _ -> None
   
  -        let readProduction fSymbol =
  +        let readProduction fSymbol index =
               let readChildrenSymbols =
                   (function | UInt16 x :: xs -> x |> fSymbol |> Option.map (fun x -> x, xs) | _ -> None)
                   |> readToEnd true
               function
  -            | UInt16 index :: UInt16 headIndex :: Empty :: xs -> maybe {
  +            | UInt16 headIndex :: Empty :: xs -> maybe {
                   let! headSymbol = fSymbol headIndex
                   let! symbols = readChildrenSymbols xs
  -                return {Index = uint32 index; Head = headSymbol; Handle = symbols}
  +                return {Index = index; Head = headSymbol; Handle = symbols}
                   }
               | _ -> None
   
  
positive.code:                     }
              | _ -> None
  
          let readCharSet =
              let readRanges =
                  function
                  | UInt16 start :: UInt16 theEnd :: xs ->
  
negative.code:                 | _ -> None
                  |> readToEnd false
              function
              | Boolean false :: UInt16 _ :: Empty :: xs ->
                  xs
                  |> readDFAEdges
                  |> Option.map (fun edges -> (index, edges) |> DFAContinue)
              | Boolean true :: UInt16 acceptIndex :: Empty :: xs -> maybe {
                  let! edges = readDFAEdges xs
                  let! acceptSymbol = fSymbol acceptIndex
                  return DFAAccept (index, (acceptSymbol, edges))
                  }
              | _ -> None
  
          let readLALRState fSymbol fProduction fLALR index =
              let readLALRAction =
                  function
                  | UInt16 symbolIndex :: xs -> maybe {
  