anchor.diff:              else
                   MessagePackException("Attempt to unpack with non-compativle type") |> raise
   
  -        let _unpackInt64 (bytes: byte[]) (sequencials: Sequencials list) (values: Value list) =
  +        let _unpackInt64 (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
               if bytes.Length >= 9 then
                   let newValue =
                       uint64(bytes.[1]) * 72057594037927936UL +
  
positive.code:             else
                  MessagePackException("Attempt to unpack with non-compatible type") |> raise
  
          let _unpackBin32 (bytes: byte[]) (sequencials: Sequencials list) (values: Value list) =
              if bytes.Length >= 5 then
                  let length = int(bytes.[1]) * 16777216 +
                               int(bytes.[2]) * 65536 +
  
negative.code:             else
                  MessagePackException("Attempt to unpack with non-compativle type") |> raise
  
          let _unpackArray16 (bytes: byte[]) (sequencials: Stack<Sequencials>) =
              if bytes.Length >= 3 then
                  let length = int(bytes.[1]) * 256 +
                               int(bytes.[2])
                  if bytes.Length - 3 >= length then
                      sequencials.Push(ArrayStore(length, Array.init length (fun _ -> Value.Nil)))
                      bytes.[3..], sequencials
                  else
                      MessagePackException("Attempt to unpack with non-compatible type") |> raise
              else
                  MessagePackException("Attempt to unpack with non-compativle type") |> raise
  
          let _unpackArray32 (bytes: byte[]) (sequencials: Stack<Sequencials>) =
              if bytes.Length >= 5 then
                  let length = int(bytes.[1]) * 16777216 +
                               int(bytes.[2]) * 65536 +
                               int(bytes.[3]) * 256 +
                               int(bytes.[4])
                  if bytes.Length - 5 >= length then
                      sequencials.Push(ArrayStore(length, Array.init length (fun _ -> Value.Nil)))
                      bytes.[5..], sequencials
                  else
                      MessagePackException("Attempt to unpack with non-compatible type") |> raise
              else
                  MessagePackException("Attempt to unpack with non-compativle type") |> raise
  
          let _unpackMap16 (bytes: byte[]) (sequencials: Stack<Sequencials>) =
              if bytes.Length >= 3 then
                  let length = int(bytes.[1]) * 256 +
                               int(bytes.[2])
                  if bytes.Length - 3 >= length * 2 then
                      sequencials.Push(MapStore(length, Value.Nil, Map.ofList []))
                      bytes.[3..], sequencials
                  else
                      MessagePackException("Attempt to unpack with non-compatible type") |> raise
              else
                  MessagePackException("Attempt to unpack with non-compativle type") |> raise
  
          let _unpackMap32 (bytes: byte[]) (sequencials: Stack<Sequencials>) =
              if bytes.Length >= 5 then
                  let length = int(bytes.[1]) * 16777216 +
                               int(bytes.[2]) * 65536 +
                               int(bytes.[3]) * 256 +
                               int(bytes.[4])
                  if bytes.Length - 5 >= length * 2 then
                      sequencials.Push(MapStore(length, Value.Nil, Map.ofList []))
                      bytes.[5..], sequencials
                  else
                      MessagePackException("Attempt to unpack with non-compatible type") |> raise
              else
                  MessagePackException("Attempt to unpack with non-compativle type") |> raise
  
          let _unpackNegativeFixint (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              let newValue = sbyte(bytes.[0]) |> Value.Int8
              let ars, vs = appendValue newValue sequencials values
              bytes.[1..], ars, vs
  
          let rec _unpack (bs: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bs.Length = 0 then values.ToArray()
              else
                  let header = bs.[0]
                  if (header &&& 0b10000000uy) = 0uy then
  