anchor.diff:  
   type BinaryPU<'a> = {Pickle : 'a * BinaryPicklerState -> BinaryPicklerState; Unpickle : BinaryUnpicklerState -> 'a * BinaryUnpicklerState}
   
  +/// Conversions functions
   module private PickleConvertors =
  +    /// perform some type conversion with exception checks on the array bounds
       let private checkConversionException f pos array =
           try
               f array
  
positive.code:     let pickleUTF32 =
          wrap (System.Text.Encoding.UTF32.GetString, System.Text.Encoding.UTF32.GetBytes) (array pickleByte)
  
  
  
  
  
negative.code:             | :? System.ArgumentOutOfRangeException as aoex -> raise <| PicklingExceededArrayLengthException(pos, Array.length array)
              | :? System.ArgumentException as aex -> raise <| PicklingExceededArrayLengthException(pos, Array.length array)
  
      /// Convert a chunk of a byte array into an int16 with exception checking
      let convInt16 pos array = checkConversionException (fun arr -> System.BitConverter.ToInt16(arr, pos)) pos array
      /// Convert a chunk of a byte array into an int32 with exception checking
      let convInt32 pos array = checkConversionException (fun arr -> System.BitConverter.ToInt32(arr, pos)) pos array
      /// Convert a chunk of a byte array into an int64 with exception checking
      let convInt64 pos array = checkConversionException (fun arr -> System.BitConverter.ToInt64(arr, pos)) pos array
      /// Convert a chunk of a byte array into an float32 with exception checking
      let convFloat32 pos array = checkConversionException (fun arr -> System.BitConverter.ToSingle(arr, pos)) pos array
      /// Convert a chunk of a byte array into an float64 with exception checking
      let convFloat64 pos array = checkConversionException (fun arr -> System.BitConverter.ToDouble(arr, pos)) pos array
      
      /// Flips an array to produce a list in the opposite order
      let arrayFlipToList a =  Array.fold(fun lst it -> it :: lst) [] a
  
      /// Converts an int16 to a byte list in reverse order
      let convFromInt16 (i16 : int16) = 
          System.BitConverter.GetBytes(i16) |> arrayFlipToList
      /// Converts an int32 to a byte list in reverse order
      let convFromInt32 (i32 : int32) = 
          System.BitConverter.GetBytes(i32) |> arrayFlipToList
      /// Converts an int64 to a byte list in reverse order
      let convFromInt64 (i64 : int64) = 
          System.BitConverter.GetBytes(i64) |> arrayFlipToList
      /// Converts an float32 to a byte list in reverse order
      let convFromFloat32 (f32 : float32) = 
          System.BitConverter.GetBytes(f32) |> arrayFlipToList
      /// Converts an float64 to a byte list in reverse order  
      let convFromFloat64 (f64 : float) = 
          System.BitConverter.GetBytes(f64) |> arrayFlipToList   
  
  /// Provides functions for pickling binary data
  module BinaryPickler =
      let private runUnpickle state x =
          match x with
  