anchor.diff:          let readCharSet _ =
               let readRanges =
                   function
  -                | UInt16 start :: UInt16 theEnd :: xs ->
  -                    (RangeSet.create (char start) (char theEnd), xs)
  +                | [UInt16 start; UInt16 theEnd] ->
  +                    RangeSet.create (char start) (char theEnd)
                       |> Some
                   | _ -> None
  -                |> readToEnd false
  +                |> readToEnd false 2
                   >> Option.map RangeSet.concat
               function
               | UInt16 _unicodePlane :: UInt16 _rangeCount
  
positive.code:             >> Option.bind (function | [x] -> Some x | _ -> None)
              >> Option.bind f
  
          let assignIndexedElements magicCode f length =
              let impl opt entries =
                  match opt, entries with
                  | Some array, UInt16 index :: 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})
  