anchor.diff:          | ArrayStore of int * Value []
           | MapStore of int * Value * Map<Value, Value>
   
  +    type Bytes(bs:byte[])=
  +      let mutable _ind=0
  +      member this.Item with get i=bs.[_ind+i]
  +      member this.IncInd d= _ind<-_ind+d;this
  +      member this.Length=bs.Length-_ind
  +      member this.Dice(startI,endI)=bs.[_ind+startI.._ind+endI]
  +
       [<CompiledName("Unpack")>]
  -    let unpack (bs: byte[]) =
  +    let unpack (bs:byte[]) =
  +        let bs=Bytes(bs)
  +        let sw=System.Diagnostics.Stopwatch.StartNew()
           let raiseMessagePackException () = MessagePackException("Attempt to unpack with non-compatible type") |> raise
   
           let appendValue (newValue: Value) (sequencials: Stack<Sequencials>) (values: List<Value>) =
  
positive.code:                     doLoop <- false
              sequencials, values
  
          let _unpackPositiveFixint (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              let ars, vs = appendValue (Value.UInt8 bytes.[0]) sequencials values
              bytes.[1..], ars, vs
  
          let _unpackFixmap (bytes: byte[]) (sequencials: Stack<Sequencials>) =
              let length = int(bytes.[0] &&& 0b00001111uy)
              if bytes.Length - 1 >= length then
                  sequencials.Push(MapStore(length, Value.Nil, Map.ofList []))
                  bytes.[1..], sequencials
              else
                  raiseMessagePackException ()
  
          let _unpackFixarray (bytes: byte[]) (sequencials: Stack<Sequencials>) =
              let length = int(bytes.[0] &&& 0b00001111uy)
              if bytes.Length - 1 >= length then
                  sequencials.Push(ArrayStore(length, Array.init length (fun _ -> Value.Nil)))
                  bytes.[1..], sequencials
              else
                  raiseMessagePackException ()
  
          let _unpackFixstr (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              let length = int(bytes.[0] &&& 0b00011111uy)
              if bytes.Length - 1 >= length then
                  let newValue = System.Text.Encoding.UTF8.GetString(bytes.[1..length]) |> Value.String
                  let ars, vs = appendValue newValue sequencials values
                  bytes.[(length+1)..], ars, vs
              else
                  raiseMessagePackException ()
  
          let _unpackNil (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              let ars, vs = appendValue Value.Nil sequencials values
              bytes.[1..], ars, vs
  
          let _unpackFalse (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              let ars, vs = appendValue (Value.Bool false) sequencials values
              bytes.[1..], ars, vs
  
          let _unpackTrue (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              let ars, vs = appendValue (Value.Bool true) sequencials values
              bytes.[1..], ars, vs
  
          let _unpackBin8 (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 2 then
                  let length = int(bytes.[1])
                  if bytes.Length - 2 >= length then
                      let newValue = Value.Bin bytes.[2..(length+1)]
                      let ars, vs = appendValue newValue sequencials values
                      bytes.[(length+2)..], ars, vs
                  else
                      raiseMessagePackException ()
              else
                  raiseMessagePackException ()
  
          let _unpackBin16 (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 3 then
                  let length = int(bytes.[1]) * 256 +
                               int(bytes.[2])
                  if bytes.Length - 3 >= length then
                      let newValue = Value.Bin bytes.[3..(length+2)]
                      let ars, vs = appendValue newValue sequencials values
                      bytes.[(length+3)..], ars, vs
                  else
                      raiseMessagePackException ()
              else
                  raiseMessagePackException ()
  
          let _unpackBin32 (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              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
                      let newValue = Value.Bin bytes.[5..(length+4)]
                      let ars, vs = appendValue newValue sequencials values
                      bytes.[(length+5)..], ars, vs
                  else
                      raiseMessagePackException ()
              else
                  raiseMessagePackException ()
  
          let _unpackExt8 (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 3 then
                  let length = int(bytes.[1])
                  if bytes.Length - 3 >= length then
                      let t = sbyte(bytes.[2])
                      let d = bytes.[3..(length+2)]
                      let ars, vs = appendValue (Value.Ext(t, d)) sequencials values
                      bytes.[(length+3)..], ars, vs
                  else
                      raiseMessagePackException ()
              else
                  raiseMessagePackException ()
  
          let _unpackExt16 (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 4 then
                  let length = int(bytes.[1]) * 256 +
                               int(bytes.[2])
                  if bytes.Length - 4 >= length then
                      let t = sbyte(bytes.[3])
                      let d = bytes.[4..(length+3)]
                      let ars, vs = appendValue (Value.Ext(t, d)) sequencials values
                      bytes.[(length+4)..], ars, vs
                  else
                      raiseMessagePackException ()
              else
                  raiseMessagePackException ()
  
          let _unpackExt32 (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 6 then
                  let length = int(bytes.[1]) * 16777216 +
                               int(bytes.[2]) * 65536 +
  
negative.code:                              int(bytes.[4])
                  if bytes.Length - 6 >= length then
                      let t = sbyte(bytes.[5])
                      let d = bytes.Dice(6,length+5)
                      let ars, vs = appendValue (Value.Ext(t, d)) sequencials values
                      bytes.IncInd (length+6), ars, vs
                  else
                      raiseMessagePackException ()
              else
                  raiseMessagePackException ()
  
          let _unpackFloat32 (bytes: Bytes) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 5 then
                  let newValue = Utility.convertEndianFromBytesToFloat32(bytes.Dice(1,4)) |> Value.Float32
                  let ars, vs = appendValue newValue sequencials values
                  bytes.IncInd 5, ars, vs
              else
                  raiseMessagePackException ()
  
          let _unpackFloat64 (bytes: Bytes) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 9 then
                  let newValue = Utility.convertEndianFromBytesToFloat(bytes.Dice(1,8)) |> Value.Float64
                  let ars, vs = appendValue newValue sequencials values
                  bytes.IncInd 9, ars, vs
              else
                  raiseMessagePackException ()
  
          let _unpackUInt8 (bytes: Bytes) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 2 then
                  let newValue = Value.UInt8 bytes.[1]
                  let ars, vs = appendValue newValue sequencials values
                  bytes.IncInd 2, ars, vs
              else
                  raiseMessagePackException ()
  
          let _unpackUInt16 (bytes: Bytes) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 3 then
                  let newValue = uint16(bytes.[1]) * 256us +
                                 uint16(bytes.[2])
                                 |> Value.UInt16
                  let ars, vs = appendValue newValue sequencials values
                  bytes.IncInd 3, ars, vs
              else
                  raiseMessagePackException ()
  
          let _unpackUInt32 (bytes: Bytes) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 5 then
                  let newValue = uint32(bytes.[1]) * 16777216u +
                                 uint32(bytes.[2]) * 65536u +
  