anchor.diff:  
       let pickleInt64 (i64 : int64) =
           {
  -        Pickle = fun _ -> i64, {Raw = (PickleConvertors.convFromInt64 i64)};
  +        Pickle = fun (i64, s) -> {Raw = (PickleConvertors.convFromInt64 i64) @ s.Raw}
           Unpickle = fun st ->
               let pos = st.Position
               let result = PickleConvertors.convInt64 pos (st.Raw)
  
positive.code:         match x with
          |{Unpickle = g; Pickle = _} -> g state
  
      let private runPickle  x =
          match x with
          |{Unpickle = _; Pickle = g} -> g  ()
  
      let return' x = {Pickle = (fun _ -> x, {Raw = []}); Unpickle = (fun s -> x, s)}
  
      let bind (x : BinaryPU<'a>) (f : 'a -> BinaryPU<'b>) = 
          match x with
          |{Unpickle = u; Pickle = p} ->
              let unpickler2 = 
                  fun s ->
                      let (a, s') = runUnpickle s x 
                      runUnpickle s' (f a)
              let pickler2 =
                  fun _ ->
                      let (a', s') = runPickle x
                      runPickle (f a')
              {Pickle = pickler2; Unpickle = unpickler2}
  
      let pickleByte b =
          {
          Pickle = fun _ -> b, {Raw = [b]};
          Unpickle = fun st ->
              let pos = st.Position
              let result = Array.item (pos) st.Raw
  
negative.code: 
      let pickleInt16 (i16 : int16) =
          {
          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 =
          {
          Pickle = fun (i32, s) -> {Raw = (PickleConvertors.convFromInt32 i32) @ s.Raw}
          Unpickle = fun st ->
              let pos = st.Position
              let result = PickleConvertors.convInt32 pos (st.Raw)
  