anchor.diff:  
           /// Convert a string into a byte list in reverse order using the supplied .NET encoding
           let private convFromStringWithDotNetEncoding (encoding : System.Text.Encoding) (str : string) =
  -            let bytes = Array.concat [encoding.GetPreamble(); encoding.GetBytes str]
  -            arrayFlipToList bytes
  +            Array.concat [encoding.GetPreamble(); encoding.GetBytes str]
   
           /// Convert a chunk of a byte array into a string with exception checking using the supplied encoding
  -        let convToEncoding pos byteCount encoding array =
  +        let convToEncoding encoding byteCount pos array =
               convToStringWithDotNetEncoding pos byteCount (Encoding.createDotNetEncoding encoding) array
   
           /// Convert a string into a byte list in reverse order using the supplied encoding
  
positive.code:         checkConversionException (unchecked pos) pos array
  
      /// Convert a chunk of a byte array into an int16 with exception checking
      let convToInt16 pos endianness array = 
          let unchecked pos arr = System.BitConverter.ToInt16(arr, pos)
          checkConversionException (unchecked pos << flipForEndianness endianness) pos array
  
      /// Convert a chunk of a byte array into an int32 with exception checking
      let convToInt32 pos endianness array = 
          let unchecked pos arr = System.BitConverter.ToInt32(arr, pos)
          checkConversionException (unchecked pos << flipForEndianness endianness) pos array
  
      /// Convert a chunk of a byte array into an int64 with exception checking
      let convToInt64 pos endianness array = 
          let unchecked pos arr = System.BitConverter.ToInt64(arr, pos)
          checkConversionException (unchecked pos << flipForEndianness endianness) pos array
  
      /// Convert a chunk of a byte array into an float32 with exception checking
      let convToFloat32 pos endianness array = 
          let unchecked pos arr = System.BitConverter.ToSingle(arr, pos)
          checkConversionException (unchecked pos << flipForEndianness endianness) pos array
  
      /// Convert a chunk of a byte array into an float64 with exception checking
      let convToFloat64 pos endianness array = 
          let unchecked pos arr = System.BitConverter.ToDouble(arr, pos)
          checkConversionException (unchecked pos << flipForEndianness endianness) pos array
  
  
negative.code:     /// A pickler/unpickler pair for bools
      let pickleBool =
          {
          Pickle = fun (b, s) -> pickleHelper (PickleConvertors.convFromBool) b s
          Unpickle = fun st -> unpickleHelper (PickleConvertors.convToBool) st
          }
  
      /// A pickler/unpickler pair for bytes
      let pickleByte =
          {
          Pickle = fun (b, s) -> pickleHelper (Array.singleton) b s
          Unpickle = fun st -> unpickleHelper (Array.item) st
          }
  
      /// A pickler/unpickler pair for int16s of the supplied endianness
      let private pickleInt16E endianness =
          {
          Pickle = fun (i16, s) -> pickleHelper (PickleConvertors.convFromInt16 endianness) i16 s
          Unpickle = fun st -> unpickleHelper (PickleConvertors.convToInt16 endianness) st
          }
  
      /// A pickler/unpickler pair for int32s of the supplied endianness
      let private pickleInt32E endianness =
          {
          Pickle = fun (i32, s) -> pickleHelper (PickleConvertors.convFromInt32 endianness) i32 s
          Unpickle = fun st -> unpickleHelper (PickleConvertors.convToInt32 endianness) st
          }
  
      /// A pickler/unpickler pair for int64s of the supplied endianness
      let private pickleInt64E endianness =
          {
          Pickle = fun (i64, s) -> pickleHelper (PickleConvertors.convFromInt64 endianness) i64 s
          Unpickle = fun st -> unpickleHelper (PickleConvertors.convToInt64 endianness) st
          }
  
      /// A pickler/unpickler pair for float32s of the supplied endianness
      let private pickleFloat32E endianness =
          {
          Pickle = fun (f32, s) -> pickleHelper (PickleConvertors.convFromFloat32 endianness) f32 s
          Unpickle = fun st -> unpickleHelper (PickleConvertors.convToFloat32 endianness) st
          }
  
      /// A pickler/unpickler pair for floats of the supplied endianness
      let private pickleFloatE endianness =
          {
          Pickle = fun (f64, s) -> pickleHelper (PickleConvertors.convFromFloat64 endianness) f64 s
          Unpickle = fun st -> unpickleHelper (PickleConvertors.convToFloat64 endianness) st
          }
  
      /// A pickler/unpickler pair for decimals of the supplied endianness
  