anchor.diff:              
   
       /// Given a value of x, returns a PU of x without affecting the underlying read/write states
  -    let lift x = {Pickle = (fun (_,st) -> st); Unpickle = (fun s -> x, s)}
  +    let lift x = EagerPU{Pickle = (fun (_,st) -> st); Unpickle = (fun s -> x, s)}
   
       /// Creates a sequential combination of PU 
  -    let sequ (f : 'b -> 'a) (pa : BinaryPU<'a>) (k : 'a -> BinaryPU<'b>) : BinaryPU<'b> =
  +    let rec sequ (f : 'b -> 'a) (pa : BinaryPU<'a>) (k : 'a -> BinaryPU<'b>) : BinaryPU<'b> =
           match pa with
  -        |{Unpickle = unPck; Pickle = pck} ->
  -            // unpickling is sequenced like bind in the reader monad
  +        |EagerPU{Unpickle = unPck; Pickle = pck} ->
  +            // unpickling is sequenced like bind in the state monad
               let unPck' s =
                   let a, s' = runUnpickle s pa
                   runUnpickle s' (k a)
  
positive.code:         wrap (intAToDecimal, System.Decimal.GetBits) (repeatA (int32PUE endianness) 4)
  
      let private byteLengthPrefixE fPickle fConv endianness pu =
          {
          Pickle = fun (v, s) -> 
              pickleHelper (fun v' -> 
                  let arr = pickle pu v'
                  let byteLen = fPickle endianness (fConv <| Array.length arr)
                  Array.concat [byteLen; arr]) v s
          Unpickle = fun st -> unpickleHelper (fun _ b -> unpickle pu (Array.skip 4 b)) st
          }
  
      /// A pickler/unpickler pair (PU) that prefixes the byte length of the structure as a (signed) int in the supplied endianness
      let private intByteLengthPrefixE endianness pu = byteLengthPrefixE PickleConvertors.convFromInt32 id endianness pu
  
negative.code: 
  open NovelFS.NovelIO
  
  type EagerBinaryPU<'a> = private {Pickle : 'a * BPickleState -> BPickleState; Unpickle : BUnpickleState -> 'a * BUnpickleState}
  
  /// A pickler/unpickler pair for type 'a
  type BinaryPU<'a> = 
      |EagerPU of EagerBinaryPU<'a> 
      |LazyPU of (unit -> BinaryPU<'a>)
      
  
  /// Provides functions for pickling binary data
  module BinaryPickler =
      let rec private runUnpickle state x =
          match x with
          |EagerPU{Unpickle = g; Pickle = _} -> g state
          |LazyPU y -> runUnpickle state (y())
  
      let rec private runPickle (a, st) x =
          match x with
          |EagerPU{Unpickle = _; Pickle = g} -> g (a, st)
          |LazyPU y -> runPickle (a,st) (y())
  
  
      /// Uses the supplied pickler/unpickler pair (PU) to unpickle the supplied byte array into some type 'a 
      let unpickle pu array =
  