anchor.diff:      /// Given a value of x, returns a pickler of x
       let lift x = {Pickle = (fun (_,st) -> st); Unpickle = (fun s -> x, s)}
   
  +    /// Creates a sequential combination of picklers 
       let sequ (f : 'b -> 'a) (pa : BinaryPU<'a>) (k : 'a -> BinaryPU<'b>) : BinaryPU<'b> =
           match pa with
           |{Unpickle = unPck; Pickle = pck} ->
  -            let unPck' = fun s ->
  +            // unpickling is sequenced like bind in the reader monad
  +            let unPck' s =
                   let a, s' = runUnpickle s pa
                   runUnpickle s' (k a)
  -            let pck' = fun (b, s) ->
  +            // pickling requires the extra projection function: f
  +            let pck' (b, s) =
                   let a = f b
                   let pb = k a
                   runPickle (a, runPickle (b, s) pb) pa
  
positive.code:             | :? System.ArgumentOutOfRangeException as aoex -> raise <| PicklingExceededArrayLengthException(pos, Array.length array)
              | :? System.ArgumentException as aex -> raise <| PicklingExceededArrayLengthException(pos, Array.length array)
  
      let convInt16 pos array = checkConversionException (fun arr -> System.BitConverter.ToInt16(arr, pos)) pos array
      let convInt32 pos array = checkConversionException (fun arr -> System.BitConverter.ToInt32(arr, pos)) pos array
      let convInt64 pos array = checkConversionException (fun arr -> System.BitConverter.ToInt64(arr, pos)) pos array
      let convFloat32 pos array = checkConversionException (fun arr -> System.BitConverter.ToSingle(arr, pos)) pos array
      let convFloat64 pos array = checkConversionException (fun arr -> System.BitConverter.ToDouble(arr, pos)) pos array
  
      let arrayFlipToList a =  a |> Array.fold(fun lst it -> it :: lst) []
  
      let convFromInt16 (i16 : int16) = 
          System.BitConverter.GetBytes(i16) |> arrayFlipToList
      let convFromInt32 (i32 : int32) = 
          System.BitConverter.GetBytes(i32) |> arrayFlipToList
      let convFromInt64 (i64 : int64) = 
          System.BitConverter.GetBytes(i64) |> arrayFlipToList
      let convFromFloat32 (f32 : float32) = 
          System.BitConverter.GetBytes(f32) |> arrayFlipToList   
      let convFromFloat64 (f64 : float) = 
          System.BitConverter.GetBytes(f64) |> arrayFlipToList   
  
  module BinaryPickler =
      let private runUnpickle state x =
          match x with
  
negative.code:     let pickleUTF32 =
          wrap (System.Text.Encoding.UTF32.GetString, System.Text.Encoding.UTF32.GetBytes) (array pickleByte)
  
      /// Pickles a decimal
      let pickleDecimal =
          let intAToDecimal (a : int[]) = System.Decimal a
          wrap (intAToDecimal, System.Decimal.GetBits) (repeatA pickleInt32 4)
  