anchor.diff:              sequ (fun (_,b,_,_) -> b) pb  (fun b ->
                   sequ (fun (_,_,c,_) -> c) pc  (fun c ->
                       sequ (fun (_,_,_,d) -> d) pd  (fun d ->
  -                        pure' (a, b, c, d)))))
  +                        lift (a, b, c, d)))))
   
       /// When supplied with a method of transforming between two types reversably and a pickler of the first of those types, returns a 
       /// pickler of the second type.
  -    let wrap (fab, fba) pa = sequ fba pa (pure' << fab)
  +    let wrap (fab, fba) pa = sequ fba pa (lift << fab)
   
       /// Repeats a pickler n times to create a list pickler
       let rec repeat pa n =
           match n with
  -        |0 -> pure' []
  +        |0 -> lift []
           |_ ->
               let pb = tuple2 pa (repeat pa (n-1))
               wrap ((fun (a, b) -> (a::b)),(fun (a::b) -> (a,b))) pb
  -
  +    
  +    /// Pickles a byte
       let pickleByte =
           {
           Pickle = fun (b, s) -> {Raw = b :: s.Raw}
  
positive.code:             result, {st with Position = pos + sizeof<int32>}
          }
  
      let pickleInt64 =
          {
          Pickle = fun (i64, s) -> {Raw = (PickleConvertors.convFromInt64 i64) @ s.Raw}
  
negative.code:             result, {st with Position = pos + sizeof<int16>}
          }
  
      /// Pickles an int32
      let pickleInt32 =
          {
          Pickle = fun (i32, s) -> {Raw = (PickleConvertors.convFromInt32 i32) @ s.Raw}
  