anchor.diff:  
       let pickleInt16 (i16 : int16) =
           {
  -        Pickle = fun _ -> i16, {Raw = (PickleConvertors.convFromInt16 i16)};
  +        Pickle = fun (i16, s) -> {Raw = (PickleConvertors.convFromInt16 i16) @ s.Raw}
           Unpickle = fun st ->
               let pos = st.Position
               let result = PickleConvertors.convInt16 pos (st.Raw)
               result, {st with Position = pos + sizeof<int16>}
           }
   
  -    let pickleInt32 (i32 : int32) =
  +    let pickleInt32 =
           {
  -        Pickle = fun _ -> i32, {Raw = (PickleConvertors.convFromInt32 i32)};
  +        Pickle = fun (i32, s) -> {Raw = (PickleConvertors.convFromInt32 i32) @ s.Raw}
           Unpickle = fun st ->
               let pos = st.Position
               let result = PickleConvertors.convInt32 pos (st.Raw)
  
positive.code: type BinaryUnpicklerState = {Raw : byte array; Position : int}
  type BinaryPicklerState = {Raw : byte list}
  
  type BinaryPU<'a> = {Pickle : unit -> 'a * BinaryPicklerState; Unpickle : BinaryUnpicklerState -> 'a * BinaryUnpicklerState}
  
  module private PickleConvertors =
      let private checkConversionException f pos array =
  
negative.code:         match x with
          |{Unpickle = g; Pickle = _} -> g state
  
      let private runPickle (a, st) x =
          match x with
          |{Unpickle = _; Pickle = g} -> g (a, st)
  
      let return' x = {Pickle = (fun (_,st) -> st); Unpickle = (fun s -> x, s)}
  
      let sequ (f : 'b -> 'a) (pa : BinaryPU<'a>) (k : 'a -> BinaryPU<'b>) : BinaryPU<'b> =
          match pa with
          |{Unpickle = g; Pickle = u} ->
              let g' = fun s ->
                  let a, s' = runUnpickle s pa
                  runUnpickle s' (k a)
              let u' = fun (b, s) ->
                  let a = f b
                  let pb = k a
                  runPickle (a, runPickle (b, s) pb) pa
              {Unpickle = g'; Pickle = u'}
  
      let tuple2 pa pb =
          sequ fst pa (fun a ->
              sequ snd pb  (fun b -> return' (a, b)))
  
      let tuple3 pa pb pc =
          sequ (fun (a,_,_) -> a) pa (fun a ->
              sequ (fun (_,b,_) -> b) pb  (fun b ->
                  sequ (fun (_,_,c) -> c) pc  (fun c ->
                      return' (a, b, c))))
  
      let tuple4 pa pb pc pd =
          sequ (fun (a,_,_,_) -> a) pa (fun a ->
              sequ (fun (_,b,_,_) -> b) pb  (fun b ->
                  sequ (fun (_,_,c,_) -> c) pc  (fun c ->
                      sequ (fun (_,_,_,d) -> d) pd  (fun d ->
                          return' (a, b, c, d)))))
  
      let wrap (fab, fba) pa = sequ fba pa (return' << fab) 
  
      let pickleByte b =
          {
          Pickle = fun (b, s) -> {Raw = b :: s.Raw}
          Unpickle = fun st ->
              let pos = st.Position
              let result = Array.item (pos) st.Raw
  