anchor.diff:                               int(bytes.[4])
                   if bytes.Length - 5 >= length * 2 then
                       sequencials.Push(MapStore(length, Value.Nil, Map.ofList []))
  -                    bytes.[5..], sequencials
  -                else
  -                    raiseMessagePackException ()
  -            else
  -                raiseMessagePackException ()
  -
  -        let _unpackNegativeFixint (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
  +                    bytes.IncInd 5, sequencials
  +                else
  +                    raiseMessagePackException ()
  +            else
  +                raiseMessagePackException ()
  +
  +        let _unpackNegativeFixint (bytes: Bytes) (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()
  +            bytes.IncInd 1, ars, vs
  +
  +        let bs,sequencials,values=bs,Stack(),List(bs.Length/2)
  +
  +        let rec _unpack()=
  +            if bs.Length = 0 then ()
               else
                   let header = bs.[0]
  +                //個々の戻り値いらなくなったので後で変えるべきだけど手を抜いてスルー
                   if (header &&& 0b10000000uy) = 0uy then
                       _unpackPositiveFixint bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif (header &&& 0b11110000uy) = 0b10000000uy then
                       _unpackFixmap bs sequencials
  -                    ||> _unpack <| values
  +                    _unpack()
                   elif (header &&& 0b11110000uy) = 0b10010000uy then
                       _unpackFixarray bs sequencials
  -                    ||> _unpack <| values
  +                    _unpack()
                   elif (header &&& 0b11100000uy) = 0b10100000uy then
                       _unpackFixstr bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif (header = Format.Nil) then
                       _unpackNil bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif (header = Format.False) then
                       _unpackFalse bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif (header = Format.True) then
                       _unpackTrue bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Bin8 then
                       _unpackBin8 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Bin16 then
                       _unpackBin16 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Bin32 then
                       _unpackBin32 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Ext8 then
                       _unpackExt8 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Ext16 then
                       _unpackExt16 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Ext32 then
                       _unpackExt32 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Float32 then
                       _unpackFloat32 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Float64 then
                       _unpackFloat64 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.UInt8 then
                       _unpackUInt8 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.UInt16 then
                       _unpackUInt16 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.UInt32 then
                       _unpackUInt32 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.UInt64 then
                       _unpackUInt64 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Int8 then
                       _unpackInt8 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Int16 then
                       _unpackInt16 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Int32 then
                       _unpackInt32 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Int64 then
                       _unpackInt64 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.FixExt1 then
                       _unpackFixExt1 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.FixExt2 then
                       _unpackFixExt2 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.FixExt4 then
                       _unpackFixExt4 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.FixExt8 then
                       _unpackFixExt8 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.FixExt16 then
                       _unpackFixExt16 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Str8 then
                       _unpackStr8 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Str16 then
                       _unpackStr16 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Str32 then
                       _unpackStr32 bs sequencials values
  -                    |||> _unpack
  +                    _unpack()
                   elif header = Format.Array16 then
                       _unpackArray16 bs sequencials
  -                    ||> _unpack <| values
  +                    _unpack()
                   elif header = Format.Array32 then
                       _unpackArray32 bs sequencials
  -                    ||> _unpack <| values
  +                    _unpack()
                   elif header = Format.Map16 then
                       _unpackMap16 bs sequencials
  -                    ||> _unpack <| values
  +                    _unpack()
                   elif header = Format.Map32 then
                       _unpackMap32 bs sequencials
  -                    ||> _unpack <| values
  +                    _unpack()
                   elif (header &&& 0b11100000uy) = 0b11100000uy then
                       _unpackNegativeFixint bs sequencials values
  -                    |||> _unpack
  -                else
  -                    values.ToArray()
  -        _unpack bs (Stack()) (List(bs.Length/2))+                    _unpack()
  +                else
  +                    ()
  +        _unpack()
  +        values.ToArray()
positive.code:                              int(bytes.[4])
                  if bytes.Length - 6 >= length then
                      let t = sbyte(bytes.[5])
                      let d = bytes.[6..(length+5)]
                      let ars, vs = appendValue (Value.Ext(t, d)) sequencials values
                      bytes.[(length+6)..], ars, vs
                  else
                      raiseMessagePackException ()
              else
                  raiseMessagePackException ()
  
          let _unpackFloat32 (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 5 then
                  let newValue = Utility.convertEndianFromBytesToFloat32(bytes.[1..4]) |> Value.Float32
                  let ars, vs = appendValue newValue sequencials values
                  bytes.[5..], ars, vs
              else
                  raiseMessagePackException ()
  
          let _unpackFloat64 (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 9 then
                  let newValue = Utility.convertEndianFromBytesToFloat(bytes.[1..8]) |> Value.Float64
                  let ars, vs = appendValue newValue sequencials values
                  bytes.[9..], ars, vs
              else
                  raiseMessagePackException ()
  
          let _unpackUInt8 (bytes: byte[]) (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.[2..], ars, vs
              else
                  raiseMessagePackException ()
  
          let _unpackUInt16 (bytes: byte[]) (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.[3..], ars, vs
              else
                  raiseMessagePackException ()
  
          let _unpackUInt32 (bytes: byte[]) (sequencials: Stack<Sequencials>) (values: List<Value>) =
              if bytes.Length >= 5 then
                  let newValue = uint32(bytes.[1]) * 16777216u +
                                 uint32(bytes.[2]) * 65536u +
  
negative.code:         | 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 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>) =
  