Add vendor to improve building speed.

This also adds ability to be built in network-constrained environment.

vendor/github.com/bytedance/sonic/internal/caching/fcache.go

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package caching
+
+import (
+    `strings`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+type FieldMap struct {
+    N uint64
+    b unsafe.Pointer
+    m map[string]int
+}
+
+type FieldEntry struct {
+    ID   int
+    Name string
+    Hash uint64
+}
+
+const (
+    FieldMap_N     = int64(unsafe.Offsetof(FieldMap{}.N))
+    FieldMap_b     = int64(unsafe.Offsetof(FieldMap{}.b))
+	FieldEntrySize = int64(unsafe.Sizeof(FieldEntry{}))
+)
+
+func newBucket(n int) unsafe.Pointer {
+    v := make([]FieldEntry, n)
+    return (*rt.GoSlice)(unsafe.Pointer(&v)).Ptr
+}
+
+func CreateFieldMap(n int) *FieldMap {
+    return &FieldMap {
+        N: uint64(n * 2),
+        b: newBucket(n * 2),    // LoadFactor = 0.5
+        m: make(map[string]int, n * 2),
+    }
+}
+
+func (self *FieldMap) At(p uint64) *FieldEntry {
+    off := uintptr(p) * uintptr(FieldEntrySize)
+    return (*FieldEntry)(unsafe.Pointer(uintptr(self.b) + off))
+}
+
+// Get searches FieldMap by name. JIT generated assembly does NOT call this
+// function, rather it implements its own version directly in assembly. So
+// we must ensure this function stays in sync with the JIT generated one.
+func (self *FieldMap) Get(name string) int {
+    h := StrHash(name)
+    p := h % self.N
+    s := self.At(p)
+
+    /* find the element;
+     * the hash map is never full, so the loop will always terminate */
+    for s.Hash != 0 {
+        if s.Hash == h && s.Name == name {
+            return s.ID
+        } else {
+            p = (p + 1) % self.N
+            s = self.At(p)
+        }
+    }
+
+    /* not found */
+    return -1
+}
+
+func (self *FieldMap) Set(name string, i int) {
+    h := StrHash(name)
+    p := h % self.N
+    s := self.At(p)
+
+    /* searching for an empty slot;
+     * the hash map is never full, so the loop will always terminate */
+    for s.Hash != 0 {
+        p = (p + 1) % self.N
+        s = self.At(p)
+    }
+
+    /* set the value */
+    s.ID   = i
+    s.Hash = h
+    s.Name = name
+
+    /* add the case-insensitive version, prefer the one with smaller field ID */
+    key := strings.ToLower(name)
+    if v, ok := self.m[key]; !ok || i < v {
+        self.m[key] = i
+    }
+}
+
+func (self *FieldMap) GetCaseInsensitive(name string) int {
+    if i, ok := self.m[strings.ToLower(name)]; ok {
+        return i
+    } else {
+        return -1
+    }
+}

vendor/github.com/bytedance/sonic/internal/caching/hashing.go

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package caching
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var (
+    V_strhash = rt.UnpackEface(strhash)
+    S_strhash = *(*uintptr)(V_strhash.Value)
+)
+
+//go:noescape
+//go:linkname strhash runtime.strhash
+func strhash(_ unsafe.Pointer, _ uintptr) uintptr
+
+func StrHash(s string) uint64 {
+    if v := strhash(unsafe.Pointer(&s), 0); v == 0 {
+        return 1
+    } else {
+        return uint64(v)
+    }
+}

vendor/github.com/bytedance/sonic/internal/caching/pcache.go

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package caching
+
+import (
+    `sync`
+    `sync/atomic`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+/** Program Map **/
+
+const (
+    _LoadFactor   = 0.5
+    _InitCapacity = 4096    // must be a power of 2
+)
+
+type _ProgramMap struct {
+    n uint64
+    m uint32
+    b []_ProgramEntry
+}
+
+type _ProgramEntry struct {
+    vt *rt.GoType
+    fn interface{}
+}
+
+func newProgramMap() *_ProgramMap {
+    return &_ProgramMap {
+        n: 0,
+        m: _InitCapacity - 1,
+        b: make([]_ProgramEntry, _InitCapacity),
+    }
+}
+
+func (self *_ProgramMap) copy() *_ProgramMap {
+    fork := &_ProgramMap{
+        n: self.n,
+        m: self.m,
+        b: make([]_ProgramEntry, len(self.b)),
+    }
+    for i, f := range self.b {
+        fork.b[i] = f
+    }
+    return fork
+}
+
+func (self *_ProgramMap) get(vt *rt.GoType) interface{} {
+    i := self.m + 1
+    p := vt.Hash & self.m
+
+    /* linear probing */
+    for ; i > 0; i-- {
+        if b := self.b[p]; b.vt == vt {
+            return b.fn
+        } else if b.vt == nil {
+            break
+        } else {
+            p = (p + 1) & self.m
+        }
+    }
+
+    /* not found */
+    return nil
+}
+
+func (self *_ProgramMap) add(vt *rt.GoType, fn interface{}) *_ProgramMap {
+    p := self.copy()
+    f := float64(atomic.LoadUint64(&p.n) + 1) / float64(p.m + 1)
+
+    /* check for load factor */
+    if f > _LoadFactor {
+        p = p.rehash()
+    }
+
+    /* insert the value */
+    p.insert(vt, fn)
+    return p
+}
+
+func (self *_ProgramMap) rehash() *_ProgramMap {
+    c := (self.m + 1) << 1
+    r := &_ProgramMap{m: c - 1, b: make([]_ProgramEntry, int(c))}
+
+    /* rehash every entry */
+    for i := uint32(0); i <= self.m; i++ {
+        if b := self.b[i]; b.vt != nil {
+            r.insert(b.vt, b.fn)
+        }
+    }
+
+    /* rebuild successful */
+    return r
+}
+
+func (self *_ProgramMap) insert(vt *rt.GoType, fn interface{}) {
+    h := vt.Hash
+    p := h & self.m
+
+    /* linear probing */
+    for i := uint32(0); i <= self.m; i++ {
+        if b := &self.b[p]; b.vt != nil {
+            p += 1
+            p &= self.m
+        } else {
+            b.vt = vt
+            b.fn = fn
+            atomic.AddUint64(&self.n, 1)
+            return
+        }
+    }
+
+    /* should never happens */
+    panic("no available slots")
+}
+
+/** RCU Program Cache **/
+
+type ProgramCache struct {
+    m sync.Mutex
+    p unsafe.Pointer
+}
+
+func CreateProgramCache() *ProgramCache {
+    return &ProgramCache {
+        m: sync.Mutex{},
+        p: unsafe.Pointer(newProgramMap()),
+    }
+}
+
+func (self *ProgramCache) Get(vt *rt.GoType) interface{} {
+    return (*_ProgramMap)(atomic.LoadPointer(&self.p)).get(vt)
+}
+
+func (self *ProgramCache) Compute(vt *rt.GoType, compute func(*rt.GoType, ... interface{}) (interface{}, error), ex ...interface{}) (interface{}, error) {
+    var err error
+    var val interface{}
+
+    /* use defer to prevent inlining of this function */
+    self.m.Lock()
+    defer self.m.Unlock()
+
+    /* double check with write lock held */
+    if val = self.Get(vt); val != nil {
+        return val, nil
+    }
+
+    /* compute the value */
+    if val, err = compute(vt, ex...); err != nil {
+        return nil, err
+    }
+
+    /* update the RCU cache */
+    atomic.StorePointer(&self.p, unsafe.Pointer((*_ProgramMap)(atomic.LoadPointer(&self.p)).add(vt, val)))
+    return val, nil
+}

vendor/github.com/bytedance/sonic/internal/cpu/features.go

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cpu
+
+import (
+    `fmt`
+    `os`
+
+    `github.com/klauspost/cpuid/v2`
+)
+
+var (
+    HasAVX  = cpuid.CPU.Has(cpuid.AVX)
+    HasAVX2 = cpuid.CPU.Has(cpuid.AVX2)
+    HasSSE = cpuid.CPU.Has(cpuid.SSE)
+)
+
+func init() {
+    switch v := os.Getenv("SONIC_MODE"); v {
+        case ""       : break
+        case "auto"   : break
+        case "noavx"  : HasAVX = false; fallthrough
+        case "noavx2" : HasAVX2 = false
+        default       : panic(fmt.Sprintf("invalid mode: '%s', should be one of 'auto', 'noavx', 'noavx2'", v))
+    }
+}

vendor/github.com/bytedance/sonic/internal/decoder/asm_stubs_amd64_go116.go

@@ -0,0 +1,130 @@
+// +build go1.16,!go1.17
+
+// Copyright 2023 CloudWeGo Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package decoder
+
+import (
+    `strconv`
+    _ `unsafe`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+var _runtime_writeBarrier uintptr = rt.GcwbAddr()
+
+//go:linkname gcWriteBarrierAX runtime.gcWriteBarrier
+func gcWriteBarrierAX()
+
+var (
+    _V_writeBarrier = jit.Imm(int64(_runtime_writeBarrier))
+
+    _F_gcWriteBarrierAX = jit.Func(gcWriteBarrierAX)
+)
+
+func (self *_Assembler) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
+    self.Emit("MOVQ", _V_writeBarrier, _R10)
+    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R10)  
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", _AX, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+func (self *_Assembler) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool, saveAX bool) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _R10)
+    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveAX {
+        self.Emit("XCHGQ", ptr, _AX)
+    } else {
+        self.Emit("MOVQ", ptr, _AX)
+    }
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R10)  
+    if saveDI {
+        self.load(_DI)
+    } 
+    if saveAX {
+        self.Emit("XCHGQ", ptr, _AX)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+
+func (self *_ValueDecoder) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
+    self.Emit("MOVQ", _V_writeBarrier, _R10)
+    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R10)  
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", _AX, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+func (self *_ValueDecoder) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _R10)
+    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, _AX)
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R10)  
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}

vendor/github.com/bytedance/sonic/internal/decoder/asm_stubs_amd64_go117.go

@@ -0,0 +1,126 @@
+// +build go1.17,!go1.21
+
+// Copyright 2023 CloudWeGo Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package decoder
+
+import (
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+//go:linkname _runtime_writeBarrier runtime.writeBarrier
+var _runtime_writeBarrier uintptr
+
+//go:linkname gcWriteBarrierAX runtime.gcWriteBarrier
+func gcWriteBarrierAX()
+
+var (
+    _V_writeBarrier = jit.Imm(int64(uintptr(unsafe.Pointer(&_runtime_writeBarrier))))
+
+    _F_gcWriteBarrierAX = jit.Func(gcWriteBarrierAX)
+)
+
+func (self *_Assembler) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
+    self.Emit("MOVQ", _V_writeBarrier, _R9)
+    self.Emit("CMPL", jit.Ptr(_R9, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.call(_F_gcWriteBarrierAX)  
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", _AX, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+func (self *_Assembler) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool, saveAX bool) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _R9)
+    self.Emit("CMPL", jit.Ptr(_R9, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveAX {
+        self.Emit("XCHGQ", ptr, _AX)
+    } else {
+        self.Emit("MOVQ", ptr, _AX)
+    }
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.call(_F_gcWriteBarrierAX) 
+    if saveDI {
+        self.load(_DI)
+    } 
+    if saveAX {
+        self.Emit("XCHGQ", ptr, _AX)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+
+func (self *_ValueDecoder) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
+    self.Emit("MOVQ", _V_writeBarrier, _R9)
+    self.Emit("CMPL", jit.Ptr(_R9, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.call(_F_gcWriteBarrierAX)
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", _AX, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+func (self *_ValueDecoder) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _AX)
+    self.Emit("CMPL", jit.Ptr(_AX, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, _AX)
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.call(_F_gcWriteBarrierAX)
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}

vendor/github.com/bytedance/sonic/internal/decoder/asm_stubs_amd64_go121.go

@@ -0,0 +1,132 @@
+// +build go1.21,!go1.23
+
+// Copyright 2023 CloudWeGo Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package decoder
+
+import (
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+//go:linkname _runtime_writeBarrier runtime.writeBarrier
+var _runtime_writeBarrier uintptr
+
+//go:nosplit
+//go:linkname gcWriteBarrier2 runtime.gcWriteBarrier2
+func gcWriteBarrier2()
+
+// Notice: gcWriteBarrier must use R11 register!!
+var _R11 = _IC
+
+var (
+    _V_writeBarrier = jit.Imm(int64(uintptr(unsafe.Pointer(&_runtime_writeBarrier))))
+
+    _F_gcWriteBarrier2 = jit.Func(gcWriteBarrier2)
+)
+
+func (self *_Assembler) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
+    self.Emit("MOVQ", _V_writeBarrier, _R9)
+    self.Emit("CMPL", jit.Ptr(_R9, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveDI {
+        self.save(_DI, _R11)
+    } else {
+        self.save(_R11)
+    }
+    self.Emit("MOVQ", _F_gcWriteBarrier2, _R11)  
+    self.Rjmp("CALL", _R11)  
+    self.Emit("MOVQ", _AX, jit.Ptr(_R11, 0))
+    self.Emit("MOVQ", rec, _DI)
+    self.Emit("MOVQ", _DI, jit.Ptr(_R11, 8))
+    if saveDI {
+        self.load(_DI, _R11)
+    } else {
+        self.load(_R11)
+    }   
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", _AX, rec)
+}
+
+func (self *_Assembler) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool, saveAX bool) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _R9)
+    self.Emit("CMPL", jit.Ptr(_R9, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveAX {
+        self.save(_AX, _R11)
+    } else {
+        self.save(_R11)
+    }
+    self.Emit("MOVQ", _F_gcWriteBarrier2, _R11)  
+    self.Rjmp("CALL", _R11)  
+    self.Emit("MOVQ", ptr, jit.Ptr(_R11, 0))
+    self.Emit("MOVQ", rec, _AX)
+    self.Emit("MOVQ", _AX, jit.Ptr(_R11, 8))
+    if saveAX {
+        self.load(_AX, _R11)
+    } else {
+        self.load(_R11)
+    }   
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+}
+
+func (self *_ValueDecoder) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
+    self.Emit("MOVQ", _V_writeBarrier, _R9)
+    self.Emit("CMPL", jit.Ptr(_R9, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveDI {
+        self.save(_DI, _R11)
+    } else {
+        self.save(_R11)
+    }
+    self.Emit("MOVQ", _F_gcWriteBarrier2, _R11)  
+    self.Rjmp("CALL", _R11)   
+    self.Emit("MOVQ", _AX, jit.Ptr(_R11, 0))
+    self.Emit("MOVQ", rec, _DI)
+    self.Emit("MOVQ", _DI, jit.Ptr(_R11, 8))
+    if saveDI {
+        self.load(_DI, _R11)
+    } else {
+        self.load(_R11)
+    }   
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", _AX, rec)
+}
+
+func (self *_ValueDecoder) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _AX)
+    self.Emit("CMPL", jit.Ptr(_AX, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.save(_R11)
+    self.Emit("MOVQ", _F_gcWriteBarrier2, _R11)  
+    self.Rjmp("CALL", _R11)     
+    self.Emit("MOVQ", ptr, jit.Ptr(_R11, 0))
+    self.Emit("MOVQ", rec, _AX)
+    self.Emit("MOVQ", _AX, jit.Ptr(_R11, 8))
+    self.load(_R11)  
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+}

vendor/github.com/bytedance/sonic/internal/decoder/debug.go

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+	`os`
+	`runtime`
+	`runtime/debug`
+	`strings`
+
+	`github.com/bytedance/sonic/internal/jit`
+)
+
+
+var (
+    debugSyncGC  = os.Getenv("SONIC_SYNC_GC") != ""
+    debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == ""
+)
+
+var (
+    _Instr_End _Instr = newInsOp(_OP_nil_1)
+
+    _F_gc       = jit.Func(runtime.GC)
+    _F_force_gc = jit.Func(debug.FreeOSMemory)
+    _F_println  = jit.Func(println_wrapper)
+    _F_print    = jit.Func(print)
+)
+
+func println_wrapper(i int, op1 int, op2 int){
+    println(i, " Intrs ", op1, _OpNames[op1], "next: ", op2, _OpNames[op2])
+}
+
+func print(i int){
+    println(i)
+}
+
+func (self *_Assembler) force_gc() {
+    self.call_go(_F_gc)
+    self.call_go(_F_force_gc)
+}
+
+func (self *_Assembler) debug_instr(i int, v *_Instr) {
+    if debugSyncGC {
+        if (i+1 == len(self.p)) {
+            self.print_gc(i, v, &_Instr_End) 
+        } else {
+            next := &(self.p[i+1])
+            self.print_gc(i, v, next)
+            name := _OpNames[next.op()]
+            if strings.Contains(name, "save") {
+                return
+            }
+        }
+        self.force_gc()
+    }
+}

vendor/github.com/bytedance/sonic/internal/decoder/decoder.go

@@ -0,0 +1,255 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `unsafe`
+    `encoding/json`
+    `reflect`
+    `runtime`
+
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/option`
+    `github.com/bytedance/sonic/utf8`
+)
+
+const (
+    _F_use_int64       = 0
+    _F_disable_urc     = 2
+    _F_disable_unknown = 3
+    _F_copy_string     = 4
+
+    _F_use_number      = types.B_USE_NUMBER
+    _F_validate_string = types.B_VALIDATE_STRING
+    _F_allow_control   = types.B_ALLOW_CONTROL
+)
+
+type Options uint64
+
+const (
+    OptionUseInt64         Options = 1 << _F_use_int64
+    OptionUseNumber        Options = 1 << _F_use_number
+    OptionUseUnicodeErrors Options = 1 << _F_disable_urc
+    OptionDisableUnknown   Options = 1 << _F_disable_unknown
+    OptionCopyString       Options = 1 << _F_copy_string
+    OptionValidateString   Options = 1 << _F_validate_string
+)
+
+func (self *Decoder) SetOptions(opts Options) {
+    if (opts & OptionUseNumber != 0) && (opts & OptionUseInt64 != 0) {
+        panic("can't set OptionUseInt64 and OptionUseNumber both!")
+    }
+    self.f = uint64(opts)
+}
+
+
+// Decoder is the decoder context object
+type Decoder struct {
+    i int
+    f uint64
+    s string
+}
+
+// NewDecoder creates a new decoder instance.
+func NewDecoder(s string) *Decoder {
+    return &Decoder{s: s}
+}
+
+// Pos returns the current decoding position.
+func (self *Decoder) Pos() int {
+    return self.i
+}
+
+func (self *Decoder) Reset(s string) {
+    self.s = s
+    self.i = 0
+    // self.f = 0
+}
+
+func (self *Decoder) CheckTrailings() error {
+    pos := self.i
+    buf := self.s
+    /* skip all the trailing spaces */
+    if pos != len(buf) {
+        for pos < len(buf) && (types.SPACE_MASK & (1 << buf[pos])) != 0 {
+            pos++
+        }
+    }
+
+    /* then it must be at EOF */
+    if pos == len(buf) {
+        return nil
+    }
+
+    /* junk after JSON value */
+    return SyntaxError {
+        Src  : buf,
+        Pos  : pos,
+        Code : types.ERR_INVALID_CHAR,
+    }
+}
+
+
+// Decode parses the JSON-encoded data from current position and stores the result
+// in the value pointed to by val.
+func (self *Decoder) Decode(val interface{}) error {
+    /* validate json if needed */
+    if (self.f & (1 << _F_validate_string)) != 0  && !utf8.ValidateString(self.s){
+        dbuf := utf8.CorrectWith(nil, rt.Str2Mem(self.s), "\ufffd")
+        self.s = rt.Mem2Str(dbuf)
+    }
+
+    vv := rt.UnpackEface(val)
+    vp := vv.Value
+
+    /* check for nil type */
+    if vv.Type == nil {
+        return &json.InvalidUnmarshalError{}
+    }
+
+    /* must be a non-nil pointer */
+    if vp == nil || vv.Type.Kind() != reflect.Ptr {
+        return &json.InvalidUnmarshalError{Type: vv.Type.Pack()}
+    }
+
+    etp := rt.PtrElem(vv.Type)
+
+    /* check the defined pointer type for issue 379 */
+    if vv.Type.IsNamed() {
+        newp := vp
+        etp  = vv.Type
+        vp   = unsafe.Pointer(&newp)
+    }
+
+    /* create a new stack, and call the decoder */
+    sb := newStack()
+    nb, err := decodeTypedPointer(self.s, self.i, etp, vp, sb, self.f)
+    /* return the stack back */
+    self.i = nb
+    freeStack(sb)
+
+    /* avoid GC ahead */
+    runtime.KeepAlive(vv)
+    return err
+}
+
+// UseInt64 indicates the Decoder to unmarshal an integer into an interface{} as an
+// int64 instead of as a float64.
+func (self *Decoder) UseInt64() {
+    self.f  |= 1 << _F_use_int64
+    self.f &^= 1 << _F_use_number
+}
+
+// UseNumber indicates the Decoder to unmarshal a number into an interface{} as a
+// json.Number instead of as a float64.
+func (self *Decoder) UseNumber() {
+    self.f &^= 1 << _F_use_int64
+    self.f  |= 1 << _F_use_number
+}
+
+// UseUnicodeErrors indicates the Decoder to return an error when encounter invalid
+// UTF-8 escape sequences.
+func (self *Decoder) UseUnicodeErrors() {
+    self.f |= 1 << _F_disable_urc
+}
+
+// DisallowUnknownFields indicates the Decoder to return an error when the destination
+// is a struct and the input contains object keys which do not match any
+// non-ignored, exported fields in the destination.
+func (self *Decoder) DisallowUnknownFields() {
+    self.f |= 1 << _F_disable_unknown
+}
+
+// CopyString indicates the Decoder to decode string values by copying instead of referring.
+func (self *Decoder) CopyString() {
+    self.f |= 1 << _F_copy_string
+}
+
+// ValidateString causes the Decoder to validate string values when decoding string value 
+// in JSON. Validation is that, returning error when unescaped control chars(0x00-0x1f) or
+// invalid UTF-8 chars in the string value of JSON.
+func (self *Decoder) ValidateString() {
+    self.f |= 1 << _F_validate_string
+}
+
+// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
+// order to reduce the first-hit latency.
+//
+// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is
+// a compile option to set the depth of recursive compile for the nested struct type.
+func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
+    cfg := option.DefaultCompileOptions()
+    for _, opt := range opts {
+        opt(&cfg)
+    }
+    return pretouchRec(map[reflect.Type]bool{vt:true}, cfg)
+}
+
+func pretouchType(_vt reflect.Type, opts option.CompileOptions) (map[reflect.Type]bool, error) {
+    /* compile function */
+    compiler := newCompiler().apply(opts)
+    decoder := func(vt *rt.GoType, _ ...interface{}) (interface{}, error) {
+        if pp, err := compiler.compile(_vt); err != nil {
+            return nil, err
+        } else {
+            as := newAssembler(pp)
+            as.name = _vt.String()
+            return as.Load(), nil
+        }
+    }
+
+    /* find or compile */
+    vt := rt.UnpackType(_vt)
+    if val := programCache.Get(vt); val != nil {
+        return nil, nil
+    } else if _, err := programCache.Compute(vt, decoder); err == nil {
+        return compiler.rec, nil
+    } else {
+        return nil, err
+    }
+}
+
+func pretouchRec(vtm map[reflect.Type]bool, opts option.CompileOptions) error {
+    if opts.RecursiveDepth < 0 || len(vtm) == 0 {
+        return nil
+    }
+    next := make(map[reflect.Type]bool)
+    for vt := range(vtm) {
+        sub, err := pretouchType(vt, opts)
+        if err != nil {
+            return err
+        }
+        for svt := range(sub) {
+            next[svt] = true
+        }
+    }
+    opts.RecursiveDepth -= 1
+    return pretouchRec(next, opts)
+}
+
+// Skip skips only one json value, and returns first non-blank character position and its ending position if it is valid.
+// Otherwise, returns negative error code using start and invalid character position using end
+func Skip(data []byte) (start int, end int) {
+    s := rt.Mem2Str(data)
+    p := 0
+    m := types.NewStateMachine()
+    ret := native.SkipOne(&s, &p, m, uint64(0))
+    types.FreeStateMachine(m) 
+    return ret, p
+}

vendor/github.com/bytedance/sonic/internal/decoder/errors.go

@@ -0,0 +1,191 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding/json`
+    `errors`
+    `fmt`
+    `reflect`
+    `strconv`
+    `strings`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+type SyntaxError struct {
+    Pos  int
+    Src  string
+    Code types.ParsingError
+    Msg  string
+}
+
+func (self SyntaxError) Error() string {
+    return fmt.Sprintf("%q", self.Description())
+}
+
+func (self SyntaxError) Description() string {
+    return "Syntax error " + self.description()
+}
+
+func (self SyntaxError) description() string {
+    /* check for empty source */
+    if self.Src == "" {
+        return fmt.Sprintf("no sources available: %#v", self)
+    }
+
+    p, x, q, y := calcBounds(len(self.Src), self.Pos)
+
+    /* compose the error description */
+    return fmt.Sprintf(
+        "at index %d: %s\n\n\t%s\n\t%s^%s\n",
+        self.Pos,
+        self.Message(),
+        self.Src[p:q],
+        strings.Repeat(".", x),
+        strings.Repeat(".", y),
+    )
+}
+
+func calcBounds(size int, pos int) (lbound int, lwidth int, rbound int, rwidth int) {
+    if pos >= size || pos < 0 {
+        return 0, 0, size, 0
+    }
+
+    i := 16
+    lbound = pos - i
+    rbound = pos + i
+
+    /* prevent slicing before the beginning */
+    if lbound < 0 {
+        lbound, rbound, i = 0, rbound - lbound, i + lbound
+    }
+
+    /* prevent slicing beyond the end */
+    if n := size; rbound > n {
+        n = rbound - n
+        rbound = size
+
+        /* move the left bound if possible */
+        if lbound > n {
+            i += n
+            lbound -= n
+        }
+    }
+
+    /* left and right length */
+    lwidth = clamp_zero(i)
+    rwidth = clamp_zero(rbound - lbound - i - 1)
+
+    return
+}
+
+func (self SyntaxError) Message() string {
+    if self.Msg == "" {
+        return self.Code.Message()
+    }
+    return self.Msg
+}
+
+func clamp_zero(v int) int {
+    if v < 0 {
+        return 0
+    } else {
+        return v
+    }
+}
+
+/** JIT Error Helpers **/
+
+var stackOverflow = &json.UnsupportedValueError {
+    Str   : "Value nesting too deep",
+    Value : reflect.ValueOf("..."),
+}
+
+func error_wrap(src string, pos int, code types.ParsingError) error {
+    return *error_wrap_heap(src, pos, code)
+}
+
+//go:noinline
+func error_wrap_heap(src string, pos int, code types.ParsingError) *SyntaxError {
+    return &SyntaxError {
+        Pos  : pos,
+        Src  : src,
+        Code : code,
+    }
+}
+
+func error_type(vt *rt.GoType) error {
+    return &json.UnmarshalTypeError{Type: vt.Pack()}
+}
+
+type MismatchTypeError struct {
+    Pos  int
+    Src  string
+    Type reflect.Type
+}
+
+func swithchJSONType (src string, pos int) string {
+    var val string
+    switch src[pos] {
+        case 'f': fallthrough
+        case 't': val = "bool"
+        case '"': val = "string"
+        case '{': val = "object"
+        case '[': val = "array"
+        case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': val = "number"        
+    }
+    return val
+}
+
+func (self MismatchTypeError) Error() string {
+    se := SyntaxError {
+        Pos  : self.Pos,
+        Src  : self.Src,
+        Code : types.ERR_MISMATCH,
+    }
+    return fmt.Sprintf("Mismatch type %s with value %s %q", self.Type.String(), swithchJSONType(self.Src, self.Pos), se.description())
+}
+
+func (self MismatchTypeError) Description() string {
+    se := SyntaxError {
+        Pos  : self.Pos,
+        Src  : self.Src,
+        Code : types.ERR_MISMATCH,
+    }
+    return fmt.Sprintf("Mismatch type %s with value %s %s", self.Type.String(), swithchJSONType(self.Src, self.Pos), se.description())
+}
+
+func error_mismatch(src string, pos int, vt *rt.GoType) error {
+    return &MismatchTypeError {
+        Pos  : pos,
+        Src  : src,
+        Type : vt.Pack(),
+    }
+}
+
+func error_field(name string) error {
+    return errors.New("json: unknown field " + strconv.Quote(name))
+}
+
+func error_value(value string, vtype reflect.Type) error {
+    return &json.UnmarshalTypeError {
+        Type  : vtype,
+        Value : value,
+    }
+}

vendor/github.com/bytedance/sonic/internal/decoder/generic_regabi_amd64.go

@@ -0,0 +1,729 @@
+// +build go1.17,!go1.23
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding/json`
+    `fmt`
+    `reflect`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/twitchyliquid64/golang-asm/obj`
+)
+
+/** Crucial Registers:
+ *
+ *      ST(R13) && 0(SP) : ro, decoder stack
+ *      DF(AX)  : ro, decoder flags
+ *      EP(BX) : wo, error pointer
+ *      IP(R10) : ro, input pointer
+ *      IL(R12) : ro, input length
+ *      IC(R11) : rw, input cursor
+ *      VP(R15) : ro, value pointer (to an interface{})
+ */
+
+const (
+    _VD_args   = 8      // 8 bytes  for passing arguments to this functions
+    _VD_fargs  = 64     // 64 bytes for passing arguments to other Go functions
+    _VD_saves  = 48     // 48 bytes for saving the registers before CALL instructions
+    _VD_locals = 96     // 96 bytes for local variables
+)
+
+const (
+    _VD_offs = _VD_fargs + _VD_saves + _VD_locals
+    _VD_size = _VD_offs + 8     // 8 bytes for the parent frame pointer
+)
+
+var (
+    _VAR_ss = _VAR_ss_Vt
+    _VAR_df = jit.Ptr(_SP, _VD_fargs + _VD_saves)
+)
+
+var (
+    _VAR_ss_Vt = jit.Ptr(_SP, _VD_fargs + _VD_saves + 8)
+    _VAR_ss_Dv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 16)
+    _VAR_ss_Iv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 24)
+    _VAR_ss_Ep = jit.Ptr(_SP, _VD_fargs + _VD_saves + 32)
+    _VAR_ss_Db = jit.Ptr(_SP, _VD_fargs + _VD_saves + 40)
+    _VAR_ss_Dc = jit.Ptr(_SP, _VD_fargs + _VD_saves + 48)
+)
+
+var (
+    _VAR_R9 = jit.Ptr(_SP, _VD_fargs + _VD_saves + 56)
+)
+type _ValueDecoder struct {
+    jit.BaseAssembler
+}
+
+var (
+    _VAR_cs_LR = jit.Ptr(_SP, _VD_fargs + _VD_saves + 64)
+    _VAR_cs_p = jit.Ptr(_SP, _VD_fargs + _VD_saves + 72)
+    _VAR_cs_n = jit.Ptr(_SP, _VD_fargs + _VD_saves + 80)
+    _VAR_cs_d = jit.Ptr(_SP, _VD_fargs + _VD_saves + 88)
+)
+
+func (self *_ValueDecoder) build() uintptr {
+    self.Init(self.compile)
+    return *(*uintptr)(self.Load("decode_value", _VD_size, _VD_args, argPtrs_generic, localPtrs_generic))
+}
+
+/** Function Calling Helpers **/
+
+func (self *_ValueDecoder) save(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _VD_saves / 8 - 1 {
+            panic("too many registers to save")
+        } else {
+            self.Emit("MOVQ", v, jit.Ptr(_SP, _VD_fargs + int64(i) * 8))
+        }
+    }
+}
+
+func (self *_ValueDecoder) load(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _VD_saves / 8 - 1 {
+            panic("too many registers to load")
+        } else {
+            self.Emit("MOVQ", jit.Ptr(_SP, _VD_fargs + int64(i) * 8), v)
+        }
+    }
+}
+
+func (self *_ValueDecoder) call(fn obj.Addr) {
+    self.Emit("MOVQ", fn, _R9)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R9)      // CALL AX
+}
+
+func (self *_ValueDecoder) call_go(fn obj.Addr) {
+    self.save(_REG_go...)   // SAVE $REG_go
+    self.call(fn)           // CALL ${fn}
+    self.load(_REG_go...)   // LOAD $REG_go
+}
+
+func (self *_ValueDecoder) callc(fn obj.Addr) {
+    self.save(_IP)  
+    self.call(fn)
+    self.load(_IP)  
+}
+
+func (self *_ValueDecoder) call_c(fn obj.Addr) {
+    self.Emit("XCHGQ", _IC, _BX)
+    self.callc(fn)
+    self.Emit("XCHGQ", _IC, _BX)
+}
+
+/** Decoder Assembler **/
+
+const (
+    _S_val = iota + 1
+    _S_arr
+    _S_arr_0
+    _S_obj
+    _S_obj_0
+    _S_obj_delim
+    _S_obj_sep
+)
+
+const (
+    _S_omask_key = (1 << _S_obj_0) | (1 << _S_obj_sep)
+    _S_omask_end = (1 << _S_obj_0) | (1 << _S_obj)
+    _S_vmask = (1 << _S_val) | (1 << _S_arr_0)
+)
+
+const (
+    _A_init_len = 1
+    _A_init_cap = 16
+)
+
+const (
+    _ST_Sp = 0
+    _ST_Vt = _PtrBytes
+    _ST_Vp = _PtrBytes * (types.MAX_RECURSE + 1)
+)
+
+var (
+    _V_true  = jit.Imm(int64(pbool(true)))
+    _V_false = jit.Imm(int64(pbool(false)))
+    _F_value = jit.Imm(int64(native.S_value))
+)
+
+var (
+    _V_max     = jit.Imm(int64(types.V_MAX))
+    _E_eof     = jit.Imm(int64(types.ERR_EOF))
+    _E_invalid = jit.Imm(int64(types.ERR_INVALID_CHAR))
+    _E_recurse = jit.Imm(int64(types.ERR_RECURSE_EXCEED_MAX))
+)
+
+var (
+    _F_convTslice    = jit.Func(convTslice)
+    _F_convTstring   = jit.Func(convTstring)
+    _F_invalid_vtype = jit.Func(invalid_vtype)
+)
+
+var (
+    _T_map     = jit.Type(reflect.TypeOf((map[string]interface{})(nil)))
+    _T_bool    = jit.Type(reflect.TypeOf(false))
+    _T_int64   = jit.Type(reflect.TypeOf(int64(0)))
+    _T_eface   = jit.Type(reflect.TypeOf((*interface{})(nil)).Elem())
+    _T_slice   = jit.Type(reflect.TypeOf(([]interface{})(nil)))
+    _T_string  = jit.Type(reflect.TypeOf(""))
+    _T_number  = jit.Type(reflect.TypeOf(json.Number("")))
+    _T_float64 = jit.Type(reflect.TypeOf(float64(0)))
+)
+
+var _R_tab = map[int]string {
+    '[': "_decode_V_ARRAY",
+    '{': "_decode_V_OBJECT",
+    ':': "_decode_V_KEY_SEP",
+    ',': "_decode_V_ELEM_SEP",
+    ']': "_decode_V_ARRAY_END",
+    '}': "_decode_V_OBJECT_END",
+}
+
+func (self *_ValueDecoder) compile() {
+    self.Emit("SUBQ", jit.Imm(_VD_size), _SP)       // SUBQ $_VD_size, SP
+    self.Emit("MOVQ", _BP, jit.Ptr(_SP, _VD_offs))  // MOVQ BP, _VD_offs(SP)
+    self.Emit("LEAQ", jit.Ptr(_SP, _VD_offs), _BP)  // LEAQ _VD_offs(SP), BP
+
+    /* initialize the state machine */
+    self.Emit("XORL", _CX, _CX)                                 // XORL CX, CX
+    self.Emit("MOVQ", _DF, _VAR_df)                             // MOVQ DF, df
+    /* initialize digital buffer first */
+    self.Emit("MOVQ", jit.Imm(_MaxDigitNums), _VAR_ss_Dc)       // MOVQ $_MaxDigitNums, ss.Dcap
+    self.Emit("LEAQ", jit.Ptr(_ST, _DbufOffset), _AX)           // LEAQ _DbufOffset(ST), AX
+    self.Emit("MOVQ", _AX, _VAR_ss_Db)                          // MOVQ AX, ss.Dbuf
+    /* add ST offset */
+    self.Emit("ADDQ", jit.Imm(_FsmOffset), _ST)                 // ADDQ _FsmOffset, _ST
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                // MOVQ CX, ST.Sp
+    self.WriteRecNotAX(0, _VP, jit.Ptr(_ST, _ST_Vp), false)                // MOVQ VP, ST.Vp[0]
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Ptr(_ST, _ST_Vt))    // MOVQ _S_val, ST.Vt[0]
+    self.Sjmp("JMP" , "_next")                                  // JMP  _next
+
+    /* set the value from previous round */
+    self.Link("_set_value")                                 // _set_value:
+    self.Emit("MOVL" , jit.Imm(_S_vmask), _DX)              // MOVL  _S_vmask, DX
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)           // MOVQ  ST.Sp, CX
+    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)   // MOVQ  ST.Vt[CX], AX
+    self.Emit("BTQ"  , _AX, _DX)                            // BTQ   AX, DX
+    self.Sjmp("JNC"  , "_vtype_error")                      // JNC   _vtype_error
+    self.Emit("XORL" , _SI, _SI)                            // XORL  SI, SI
+    self.Emit("SUBQ" , jit.Imm(1), jit.Ptr(_ST, _ST_Sp))    // SUBQ  $1, ST.Sp
+    self.Emit("XCHGQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)   // XCHGQ ST.Vp[CX], SI
+    self.Emit("MOVQ" , _R8, jit.Ptr(_SI, 0))                // MOVQ  R8, (SI)
+    self.WriteRecNotAX(1, _R9, jit.Ptr(_SI, 8), false)           // MOVQ  R9, 8(SI)
+
+    /* check for value stack */
+    self.Link("_next")                              // _next:
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _AX)   // MOVQ  ST.Sp, AX
+    self.Emit("TESTQ", _AX, _AX)                    // TESTQ AX, AX
+    self.Sjmp("JS"   , "_return")                   // JS    _return
+
+    /* fast path: test up to 4 characters manually */
+    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+    self.Emit("MOVQ"   , jit.Imm(_BM_space), _DX)       // MOVQ    _BM_space, DX
+    self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+    self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
+    self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
+    self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
+    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+
+    /* at least 1 to 3 spaces */
+    for i := 0; i < 3; i++ {
+        self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+        self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+        self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+        self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+        self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
+        self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
+        self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
+        self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+    }
+
+    /* at least 4 spaces */
+    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+
+    /* fast path: use lookup table to select decoder */
+    self.Link("_decode_fast")                           // _decode_fast:
+    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ    ?(PC), DI
+    self.Sref("_decode_tab", 4)                         // ....    &_decode_tab
+    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, 0), _AX)  // MOVLQSX (DI)(AX*4), AX
+    self.Emit("TESTQ"  , _AX, _AX)                      // TESTQ   AX, AX
+    self.Sjmp("JZ"     , "_decode_native")              // JZ      _decode_native
+    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+    self.Emit("ADDQ"   , _DI, _AX)                      // ADDQ    DI, AX
+    self.Rjmp("JMP"    , _AX)                           // JMP     AX
+
+    /* decode with native decoder */
+    self.Link("_decode_native")         // _decode_native:
+    self.Emit("MOVQ", _IP, _DI)         // MOVQ IP, DI
+    self.Emit("MOVQ", _IL, _SI)         // MOVQ IL, SI
+    self.Emit("MOVQ", _IC, _DX)         // MOVQ IC, DX
+    self.Emit("LEAQ", _VAR_ss, _CX)     // LEAQ ss, CX
+    self.Emit("MOVQ", _VAR_df, _R8)     // MOVQ $df, R8
+    self.Emit("BTSQ", jit.Imm(_F_allow_control), _R8)  // ANDQ $1<<_F_allow_control, R8
+    self.callc(_F_value)                // CALL value
+    self.Emit("MOVQ", _AX, _IC)         // MOVQ AX, IC
+
+    /* check for errors */
+    self.Emit("MOVQ" , _VAR_ss_Vt, _AX)     // MOVQ  ss.Vt, AX
+    self.Emit("TESTQ", _AX, _AX)            // TESTQ AX, AX
+    self.Sjmp("JS"   , "_parsing_error")       
+    self.Sjmp("JZ"   , "_invalid_vtype")    // JZ    _invalid_vtype
+    self.Emit("CMPQ" , _AX, _V_max)         // CMPQ  AX, _V_max
+    self.Sjmp("JA"   , "_invalid_vtype")    // JA    _invalid_vtype
+
+    /* jump table selector */
+    self.Byte(0x48, 0x8d, 0x3d)                             // LEAQ    ?(PC), DI
+    self.Sref("_switch_table", 4)                           // ....    &_switch_table
+    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, -4), _AX)     // MOVLQSX -4(DI)(AX*4), AX
+    self.Emit("ADDQ"   , _DI, _AX)                          // ADDQ    DI, AX
+    self.Rjmp("JMP"    , _AX)                               // JMP     AX
+
+    /** V_EOF **/
+    self.Link("_decode_V_EOF")          // _decode_V_EOF:
+    self.Emit("MOVL", _E_eof, _EP)      // MOVL _E_eof, EP
+    self.Sjmp("JMP" , "_error")         // JMP  _error
+
+    /** V_NULL **/
+    self.Link("_decode_V_NULL")                 // _decode_V_NULL:
+    self.Emit("XORL", _R8, _R8)                 // XORL R8, R8
+    self.Emit("XORL", _R9, _R9)                 // XORL R9, R9
+    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_TRUE **/
+    self.Link("_decode_V_TRUE")                 // _decode_V_TRUE:
+    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
+    // TODO: maybe modified by users?
+    self.Emit("MOVQ", _V_true, _R9)             // MOVQ _V_true, R9 
+    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_FALSE **/
+    self.Link("_decode_V_FALSE")                // _decode_V_FALSE:
+    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
+    self.Emit("MOVQ", _V_false, _R9)            // MOVQ _V_false, R9
+    self.Emit("LEAQ", jit.Ptr(_IC, -5), _DI)    // LEAQ -5(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_ARRAY **/
+    self.Link("_decode_V_ARRAY")                            // _decode_V_ARRAY
+    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)               // MOVL _S_vmask, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DX)                             // BTQ  AX, DX
+    self.Sjmp("JNC" , "_invalid_char")                      // JNC  _invalid_char
+
+    /* create a new array */
+    self.Emit("MOVQ", _T_eface, _AX)                            // MOVQ    _T_eface, AX
+    self.Emit("MOVQ", jit.Imm(_A_init_len), _BX)                // MOVQ    _A_init_len, BX
+    self.Emit("MOVQ", jit.Imm(_A_init_cap), _CX)                // MOVQ    _A_init_cap, CX
+    self.call_go(_F_makeslice)                                  // CALL_GO runtime.makeslice
+
+    /* pack into an interface */
+    self.Emit("MOVQ", jit.Imm(_A_init_len), _BX)                // MOVQ    _A_init_len, BX
+    self.Emit("MOVQ", jit.Imm(_A_init_cap), _CX)                // MOVQ    _A_init_cap, CX
+    self.call_go(_F_convTslice)                                 // CALL_GO runtime.convTslice
+    self.Emit("MOVQ", _AX, _R8)                                 // MOVQ    AX, R8
+
+    /* replace current state with an array */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Imm(_S_arr), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_arr, ST.Vt[CX]
+    self.Emit("MOVQ", _T_slice, _AX)                                    // MOVQ _T_slice, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 0))                             // MOVQ AX, (SI)
+    self.WriteRecNotAX(2, _R8, jit.Ptr(_SI, 8), false)                  // MOVQ R8, 8(SI)
+
+    /* add a new slot for the first element */
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
+    self.Emit("MOVQ", jit.Ptr(_R8, 0), _AX)                             // MOVQ (R8), AX
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
+    self.WritePtrAX(3, jit.Sib(_ST, _CX, 8, _ST_Vp), false)             // MOVQ AX, ST.Vp[CX]
+    self.Emit("MOVQ", jit.Imm(_S_arr_0), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_arr_0, ST.Vt[CX]
+    self.Sjmp("JMP" , "_next")                                          // JMP  _next
+
+    /** V_OBJECT **/
+    self.Link("_decode_V_OBJECT")                                       // _decode_V_OBJECT:
+    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)                           // MOVL    _S_vmask, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                // MOVQ    ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DX)                                         // BTQ     AX, DX
+    self.Sjmp("JNC" , "_invalid_char")                                  // JNC     _invalid_char
+    self.call_go(_F_makemap_small)                                      // CALL_GO runtime.makemap_small
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
+    self.Emit("MOVQ", jit.Imm(_S_obj_0), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ    _S_obj_0, ST.Vt[CX]
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ    ST.Vp[CX], SI
+    self.Emit("MOVQ", _T_map, _DX)                                      // MOVQ    _T_map, DX
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 0))                             // MOVQ    DX, (SI)
+    self.WritePtrAX(4, jit.Ptr(_SI, 8), false)                          // MOVQ    AX, 8(SI)
+    self.Sjmp("JMP" , "_next")                                          // JMP     _next
+
+    /** V_STRING **/
+    self.Link("_decode_V_STRING")       // _decode_V_STRING:
+    self.Emit("MOVQ", _VAR_ss_Iv, _CX)  // MOVQ ss.Iv, CX
+    self.Emit("MOVQ", _IC, _AX)         // MOVQ IC, AX
+    self.Emit("SUBQ", _CX, _AX)         // SUBQ CX, AX
+
+    /* check for escapes */
+    self.Emit("CMPQ", _VAR_ss_Ep, jit.Imm(-1))          // CMPQ ss.Ep, $-1
+    self.Sjmp("JNE" , "_unquote")                       // JNE  _unquote
+    self.Emit("SUBQ", jit.Imm(1), _AX)                  // SUBQ $1, AX
+    self.Emit("LEAQ", jit.Sib(_IP, _CX, 1, 0), _R8)     // LEAQ (IP)(CX), R8
+    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ (PC), DI
+    self.Sref("_copy_string_end", 4)
+    self.Emit("BTQ", jit.Imm(_F_copy_string), _VAR_df)
+    self.Sjmp("JC", "copy_string")
+    self.Link("_copy_string_end")                                 
+    self.Emit("XORL", _DX, _DX)   
+
+    /* strings with no escape sequences */
+    self.Link("_noescape")                                  // _noescape:
+    self.Emit("MOVL", jit.Imm(_S_omask_key), _DI)               // MOVL _S_omask, DI
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _SI)    // MOVQ ST.Vt[CX], SI
+    self.Emit("BTQ" , _SI, _DI)                             // BTQ  SI, DI
+    self.Sjmp("JC"  , "_object_key")                        // JC   _object_key
+
+    /* check for pre-packed strings, avoid 1 allocation */
+    self.Emit("TESTQ", _DX, _DX)                // TESTQ   DX, DX
+    self.Sjmp("JNZ"  , "_packed_str")           // JNZ     _packed_str
+    self.Emit("MOVQ" , _AX, _BX)                // MOVQ    AX, BX
+    self.Emit("MOVQ" , _R8, _AX)                // MOVQ    R8, AX
+    self.call_go(_F_convTstring)                // CALL_GO runtime.convTstring
+    self.Emit("MOVQ" , _AX, _R9)                // MOVQ    AX, R9
+
+    /* packed string already in R9 */
+    self.Link("_packed_str")            // _packed_str:
+    self.Emit("MOVQ", _T_string, _R8)   // MOVQ _T_string, R8
+    self.Emit("MOVQ", _VAR_ss_Iv, _DI)  // MOVQ ss.Iv, DI
+    self.Emit("SUBQ", jit.Imm(1), _DI)  // SUBQ $1, DI
+    self.Sjmp("JMP" , "_set_value")     // JMP  _set_value
+
+    /* the string is an object key, get the map */
+    self.Link("_object_key")
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+
+    /* add a new delimiter */
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                      // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                      // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow")                                    // JA   _stack_overflow
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                            // MOVQ CX, ST.Sp
+    self.Emit("MOVQ", jit.Imm(_S_obj_delim), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_obj_delim, ST.Vt[CX]
+
+    /* add a new slot int the map */
+    self.Emit("MOVQ", _AX, _DI)                         // MOVQ    AX, DI
+    self.Emit("MOVQ", _T_map, _AX)                      // MOVQ    _T_map, AX
+    self.Emit("MOVQ", _SI, _BX)                         // MOVQ    SI, BX
+    self.Emit("MOVQ", _R8, _CX)                         // MOVQ    R9, CX
+    self.call_go(_F_mapassign_faststr)                  // CALL_GO runtime.mapassign_faststr
+
+    /* add to the pointer stack */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                 // MOVQ ST.Sp, CX
+    self.WritePtrAX(6, jit.Sib(_ST, _CX, 8, _ST_Vp), false)    // MOVQ AX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                                   // JMP  _next
+
+    /* allocate memory to store the string header and unquoted result */
+    self.Link("_unquote")                               // _unquote:
+    self.Emit("ADDQ", jit.Imm(15), _AX)                 // ADDQ    $15, AX
+    self.Emit("MOVQ", _T_byte, _BX)                     // MOVQ    _T_byte, BX
+    self.Emit("MOVB", jit.Imm(0), _CX)                  // MOVB    $0, CX
+    self.call_go(_F_mallocgc)                           // CALL_GO runtime.mallocgc
+    self.Emit("MOVQ", _AX, _R9)                         // MOVQ    AX, R9
+
+    /* prepare the unquoting parameters */
+    self.Emit("MOVQ" , _VAR_ss_Iv, _CX)                         // MOVQ  ss.Iv, CX
+    self.Emit("LEAQ" , jit.Sib(_IP, _CX, 1, 0), _DI)            // LEAQ  (IP)(CX), DI
+    self.Emit("NEGQ" , _CX)                                     // NEGQ  CX
+    self.Emit("LEAQ" , jit.Sib(_IC, _CX, 1, -1), _SI)           // LEAQ  -1(IC)(CX), SI
+    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _DX)                   // LEAQ  16(R8), DX
+    self.Emit("LEAQ" , _VAR_ss_Ep, _CX)                         // LEAQ  ss.Ep, CX
+    self.Emit("XORL" , _R8, _R8)                                // XORL  R8, R8
+    self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _VAR_df)        // BTQ   ${_F_disable_urc}, fv
+    self.Emit("SETCC", _R8)                                     // SETCC R8
+    self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _R8)   // SHLQ  ${types.B_UNICODE_REPLACE}, R8
+
+    /* unquote the string, with R9 been preserved */
+    self.Emit("MOVQ", _R9, _VAR_R9)             // SAVE R9
+    self.call_c(_F_unquote)                     // CALL unquote
+    self.Emit("MOVQ", _VAR_R9, _R9)             // LOAD R9
+
+    /* check for errors */
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
+    self.Sjmp("JS"   , "_unquote_error")        // JS    _unquote_error
+    self.Emit("MOVL" , jit.Imm(1), _DX)         // MOVL  $1, DX
+    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _R8)   // ADDQ  $16, R8
+    self.Emit("MOVQ" , _R8, jit.Ptr(_R9, 0))    // MOVQ  R8, (R9)
+    self.Emit("MOVQ" , _AX, jit.Ptr(_R9, 8))    // MOVQ  AX, 8(R9)
+    self.Sjmp("JMP"  , "_noescape")             // JMP   _noescape
+
+    /** V_DOUBLE **/
+    self.Link("_decode_V_DOUBLE")                           // _decode_V_DOUBLE:
+    self.Emit("BTQ"  , jit.Imm(_F_use_number), _VAR_df)     // BTQ     _F_use_number, df
+    self.Sjmp("JC"   , "_use_number")                       // JC      _use_number
+    self.Emit("MOVSD", _VAR_ss_Dv, _X0)                     // MOVSD   ss.Dv, X0
+    self.Sjmp("JMP"  , "_use_float64")                      // JMP     _use_float64
+
+    /** V_INTEGER **/
+    self.Link("_decode_V_INTEGER")                          // _decode_V_INTEGER:
+    self.Emit("BTQ"     , jit.Imm(_F_use_number), _VAR_df)  // BTQ      _F_use_number, df
+    self.Sjmp("JC"      , "_use_number")                    // JC       _use_number
+    self.Emit("BTQ"     , jit.Imm(_F_use_int64), _VAR_df)   // BTQ      _F_use_int64, df
+    self.Sjmp("JC"      , "_use_int64")                     // JC       _use_int64
+    //TODO: use ss.Dv directly
+    self.Emit("MOVSD", _VAR_ss_Dv, _X0)                  // MOVSD   ss.Dv, X0
+
+    /* represent numbers as `float64` */
+    self.Link("_use_float64")                   // _use_float64:
+    self.Emit("MOVQ" , _X0, _AX)                // MOVQ   X0, AX
+    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
+    self.Emit("MOVQ" , _T_float64, _R8)         // MOVQ    _T_float64, R8
+    self.Emit("MOVQ" , _AX, _R9)                // MOVQ    AX, R9
+    self.Emit("MOVQ" , _VAR_ss_Ep, _DI)         // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP"  , "_set_value")            // JMP     _set_value
+
+    /* represent numbers as `json.Number` */
+    self.Link("_use_number")                            // _use_number
+    self.Emit("MOVQ", _VAR_ss_Ep, _AX)                  // MOVQ    ss.Ep, AX
+    self.Emit("LEAQ", jit.Sib(_IP, _AX, 1, 0), _SI)     // LEAQ    (IP)(AX), SI
+    self.Emit("MOVQ", _IC, _CX)                         // MOVQ    IC, CX
+    self.Emit("SUBQ", _AX, _CX)                         // SUBQ    AX, CX
+    self.Emit("MOVQ", _SI, _AX)                         // MOVQ    SI, AX
+    self.Emit("MOVQ", _CX, _BX)                         // MOVQ    CX, BX
+    self.call_go(_F_convTstring)                        // CALL_GO runtime.convTstring
+    self.Emit("MOVQ", _T_number, _R8)                   // MOVQ    _T_number, R8
+    self.Emit("MOVQ", _AX, _R9)                         // MOVQ    AX, R9
+    self.Emit("MOVQ", _VAR_ss_Ep, _DI)                  // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP" , "_set_value")                     // JMP     _set_value
+
+    /* represent numbers as `int64` */
+    self.Link("_use_int64")                     // _use_int64:
+    self.Emit("MOVQ", _VAR_ss_Iv, _AX)          // MOVQ    ss.Iv, AX
+    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
+    self.Emit("MOVQ", _T_int64, _R8)            // MOVQ    _T_int64, R8
+    self.Emit("MOVQ", _AX, _R9)                 // MOVQ    AX, R9
+    self.Emit("MOVQ", _VAR_ss_Ep, _DI)          // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP" , "_set_value")             // JMP     _set_value
+
+    /** V_KEY_SEP **/
+    self.Link("_decode_V_KEY_SEP")                                          // _decode_V_KEY_SEP:
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                    // MOVQ ST.Vt[CX], AX
+    self.Emit("CMPQ", _AX, jit.Imm(_S_obj_delim))                           // CMPQ AX, _S_obj_delim
+    self.Sjmp("JNE" , "_invalid_char")                                      // JNE  _invalid_char
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))        // MOVQ _S_val, ST.Vt[CX]
+    self.Emit("MOVQ", jit.Imm(_S_obj), jit.Sib(_ST, _CX, 8, _ST_Vt - 8))    // MOVQ _S_obj, ST.Vt[CX - 1]
+    self.Sjmp("JMP" , "_next")                                              // JMP  _next
+
+    /** V_ELEM_SEP **/
+    self.Link("_decode_V_ELEM_SEP")                          // _decode_V_ELEM_SEP:
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ     ST.Sp, CX
+    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ     ST.Vt[CX], AX
+    self.Emit("CMPQ" , _AX, jit.Imm(_S_arr))      
+    self.Sjmp("JE"   , "_array_sep")                         // JZ       _next
+    self.Emit("CMPQ" , _AX, jit.Imm(_S_obj))                 // CMPQ     _AX, _S_arr
+    self.Sjmp("JNE"  , "_invalid_char")                      // JNE      _invalid_char
+    self.Emit("MOVQ" , jit.Imm(_S_obj_sep), jit.Sib(_ST, _CX, 8, _ST_Vt))
+    self.Sjmp("JMP"  , "_next")                              // JMP      _next
+
+    /* arrays */
+    self.Link("_array_sep")
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _DX)                 // MOVQ 8(SI), DX
+    self.Emit("CMPQ", _DX, jit.Ptr(_SI, 16))                // CMPQ DX, 16(SI)
+    self.Sjmp("JAE" , "_array_more")                        // JAE  _array_more
+
+    /* add a slot for the new element */
+    self.Link("_array_append")                                          // _array_append:
+    self.Emit("ADDQ", jit.Imm(1), jit.Ptr(_SI, 8))                      // ADDQ $1, 8(SI)
+    self.Emit("MOVQ", jit.Ptr(_SI, 0), _SI)                             // MOVQ (SI), SI
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
+    self.Emit("SHLQ", jit.Imm(1), _DX)                                  // SHLQ $1, DX
+    self.Emit("LEAQ", jit.Sib(_SI, _DX, 8, 0), _SI)                     // LEAQ (SI)(DX*8), SI
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
+    self.WriteRecNotAX(7 , _SI, jit.Sib(_ST, _CX, 8, _ST_Vp), false)           // MOVQ SI, ST.Vp[CX]
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_val, ST.Vt[CX}
+    self.Sjmp("JMP" , "_next")                                          // JMP  _next
+
+    /** V_ARRAY_END **/
+    self.Link("_decode_V_ARRAY_END")                        // _decode_V_ARRAY_END:
+    self.Emit("XORL", _DX, _DX)                             // XORL DX, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("CMPQ", _AX, jit.Imm(_S_arr_0))               // CMPQ AX, _S_arr_0
+    self.Sjmp("JE"  , "_first_item")                        // JE   _first_item
+    self.Emit("CMPQ", _AX, jit.Imm(_S_arr))                 // CMPQ AX, _S_arr
+    self.Sjmp("JNE" , "_invalid_char")                      // JNE  _invalid_char
+    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ DX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                              // JMP  _next
+
+    /* first element of an array */
+    self.Link("_first_item")                                    // _first_item:
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                // MOVQ ST.Sp, CX
+    self.Emit("SUBQ", jit.Imm(2), jit.Ptr(_ST, _ST_Sp))         // SUBQ $2, ST.Sp
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp - 8), _SI)    // MOVQ ST.Vp[CX - 1], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                     // MOVQ 8(SI), SI
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp - 8))    // MOVQ DX, ST.Vp[CX - 1]
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))        // MOVQ DX, ST.Vp[CX]
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                     // MOVQ DX, 8(SI)
+    self.Sjmp("JMP" , "_next")                                  // JMP  _next
+
+    /** V_OBJECT_END **/
+    self.Link("_decode_V_OBJECT_END")                       // _decode_V_OBJECT_END:
+    self.Emit("MOVL", jit.Imm(_S_omask_end), _DI)           // MOVL _S_omask, DI
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DI)                    
+    self.Sjmp("JNC" , "_invalid_char")                      // JNE  _invalid_char
+    self.Emit("XORL", _AX, _AX)                             // XORL AX, AX
+    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
+    self.Emit("MOVQ", _AX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ AX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                              // JMP  _next
+
+    /* return from decoder */
+    self.Link("_return")                            // _return:
+    self.Emit("XORL", _EP, _EP)                     // XORL EP, EP
+    self.Emit("MOVQ", _EP, jit.Ptr(_ST, _ST_Vp))    // MOVQ EP, ST.Vp[0]
+    self.Link("_epilogue")                          // _epilogue:
+    self.Emit("SUBQ", jit.Imm(_FsmOffset), _ST)     // SUBQ _FsmOffset, _ST
+    self.Emit("MOVQ", jit.Ptr(_SP, _VD_offs), _BP)  // MOVQ _VD_offs(SP), BP
+    self.Emit("ADDQ", jit.Imm(_VD_size), _SP)       // ADDQ $_VD_size, SP
+    self.Emit("RET")                                // RET
+
+    /* array expand */
+    self.Link("_array_more")                    // _array_more:
+    self.Emit("MOVQ" , _T_eface, _AX)           // MOVQ    _T_eface, AX
+    self.Emit("MOVQ" , jit.Ptr(_SI, 0), _BX)    // MOVQ   (SI), BX
+    self.Emit("MOVQ" , jit.Ptr(_SI, 8), _CX)    // MOVQ   8(SI), CX
+    self.Emit("MOVQ" , jit.Ptr(_SI, 16), _DI)   // MOVQ    16(SI), DI
+    self.Emit("MOVQ" , _DI, _SI)                // MOVQ    DI, 24(SP)
+    self.Emit("SHLQ" , jit.Imm(1), _SI)         // SHLQ    $1, SI
+    self.call_go(_F_growslice)                  // CALL_GO runtime.growslice
+    self.Emit("MOVQ" , _AX, _DI)                // MOVQ   AX, DI
+    self.Emit("MOVQ" , _BX, _DX)                // MOVQ   BX, DX
+    self.Emit("MOVQ" , _CX, _AX)                // MOVQ   CX, AX
+             
+    /* update the slice */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                 // MOVQ DX, 8(SI)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 16))                // MOVQ AX, 16(AX)
+    self.WriteRecNotAX(8 , _DI, jit.Ptr(_SI, 0), false)                 // MOVQ R10, (SI)
+    self.Sjmp("JMP" , "_array_append")                      // JMP  _array_append
+
+    /* copy string */
+    self.Link("copy_string")  // pointer: R8, length: AX, return addr: DI
+    self.Emit("MOVQ", _R8, _VAR_cs_p)
+    self.Emit("MOVQ", _AX, _VAR_cs_n)
+    self.Emit("MOVQ", _DI, _VAR_cs_LR)
+    self.Emit("MOVQ", _AX, _BX)
+    self.Emit("MOVQ", _AX, _CX)
+    self.Emit("MOVQ", _T_byte, _AX)
+    self.call_go(_F_makeslice)                              
+    self.Emit("MOVQ", _AX, _VAR_cs_d)                    
+    self.Emit("MOVQ", _VAR_cs_p, _BX)
+    self.Emit("MOVQ", _VAR_cs_n, _CX)
+    self.call_go(_F_memmove)
+    self.Emit("MOVQ", _VAR_cs_d, _R8)
+    self.Emit("MOVQ", _VAR_cs_n, _AX)
+    self.Emit("MOVQ", _VAR_cs_LR, _DI)
+    self.Rjmp("JMP", _DI)
+
+    /* error handlers */
+    self.Link("_stack_overflow")
+    self.Emit("MOVL" , _E_recurse, _EP)         // MOVQ  _E_recurse, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_vtype_error")                   // _vtype_error:
+    self.Emit("MOVQ" , _DI, _IC)                // MOVQ  DI, IC
+    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_invalid_char")                  // _invalid_char:
+    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
+    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_unquote_error")                 // _unquote_error:
+    self.Emit("MOVQ" , _VAR_ss_Iv, _IC)         // MOVQ  ss.Iv, IC
+    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
+    self.Link("_parsing_error")                 // _parsing_error:
+    self.Emit("NEGQ" , _AX)                     // NEGQ  AX
+    self.Emit("MOVQ" , _AX, _EP)                // MOVQ  AX, EP
+    self.Link("_error")                         // _error:
+    self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
+    self.Sjmp("JMP"  , "_epilogue")             // JMP   _epilogue
+
+    /* invalid value type, never returns */
+    self.Link("_invalid_vtype")
+    self.call_go(_F_invalid_vtype)                 // CALL invalid_type
+    self.Emit("UD2")                            // UD2
+
+    /* switch jump table */
+    self.Link("_switch_table")              // _switch_table:
+    self.Sref("_decode_V_EOF", 0)           // SREF &_decode_V_EOF, $0
+    self.Sref("_decode_V_NULL", -4)         // SREF &_decode_V_NULL, $-4
+    self.Sref("_decode_V_TRUE", -8)         // SREF &_decode_V_TRUE, $-8
+    self.Sref("_decode_V_FALSE", -12)       // SREF &_decode_V_FALSE, $-12
+    self.Sref("_decode_V_ARRAY", -16)       // SREF &_decode_V_ARRAY, $-16
+    self.Sref("_decode_V_OBJECT", -20)      // SREF &_decode_V_OBJECT, $-20
+    self.Sref("_decode_V_STRING", -24)      // SREF &_decode_V_STRING, $-24
+    self.Sref("_decode_V_DOUBLE", -28)      // SREF &_decode_V_DOUBLE, $-28
+    self.Sref("_decode_V_INTEGER", -32)     // SREF &_decode_V_INTEGER, $-32
+    self.Sref("_decode_V_KEY_SEP", -36)     // SREF &_decode_V_KEY_SEP, $-36
+    self.Sref("_decode_V_ELEM_SEP", -40)    // SREF &_decode_V_ELEM_SEP, $-40
+    self.Sref("_decode_V_ARRAY_END", -44)   // SREF &_decode_V_ARRAY_END, $-44
+    self.Sref("_decode_V_OBJECT_END", -48)  // SREF &_decode_V_OBJECT_END, $-48
+
+    /* fast character lookup table */
+    self.Link("_decode_tab")        // _decode_tab:
+    self.Sref("_decode_V_EOF", 0)   // SREF &_decode_V_EOF, $0
+
+    /* generate rest of the tabs */
+    for i := 1; i < 256; i++ {
+        if to, ok := _R_tab[i]; ok {
+            self.Sref(to, -int64(i) * 4)
+        } else {
+            self.Byte(0x00, 0x00, 0x00, 0x00)
+        }
+    }
+}
+
+/** Generic Decoder **/
+
+var (
+    _subr_decode_value = new(_ValueDecoder).build()
+)
+
+//go:nosplit
+func invalid_vtype(vt types.ValueType) {
+    throw(fmt.Sprintf("invalid value type: %d", vt))
+}

vendor/github.com/bytedance/sonic/internal/decoder/generic_regabi_amd64_test.s

@@ -0,0 +1,37 @@
+// +build go1.17,!go1.23
+
+//
+// Copyright 2021 ByteDance Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·decodeValueStub(SB), NOSPLIT, $0 - 72
+    NO_LOCAL_POINTERS
+    PXOR  X0, X0
+    MOVOU X0, rv+48(FP)
+    MOVQ  st+0(FP) , R13
+    MOVQ  sp+8(FP) , R10
+    MOVQ  sn+16(FP), R12
+    MOVQ  ic+24(FP), R11
+    MOVQ  vp+32(FP), R15
+    MOVQ  df+40(FP), AX
+    MOVQ  ·_subr_decode_value(SB), BX
+    CALL  BX
+    MOVQ  R11, rp+48(FP)
+    MOVQ  BX, ex+56(FP)
+    RET

vendor/github.com/bytedance/sonic/internal/decoder/generic_stkabi_amd64.go

@@ -0,0 +1,733 @@
+// +build go1.16,!go1.17
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding/json`
+    `fmt`
+    `reflect`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/twitchyliquid64/golang-asm/obj`
+)
+
+/** Crucial Registers:
+ *
+ *      ST(BX)  : ro, decoder stack
+ *      DF(R10) : ro, decoder flags
+ *      EP(R11) : wo, error pointer
+ *      IP(R12) : ro, input pointer
+ *      IL(R13) : ro, input length
+ *      IC(R14) : rw, input cursor
+ *      VP(R15) : ro, value pointer (to an interface{})
+ */
+
+const (
+    _VD_args   = 8      // 8 bytes  for passing arguments to this functions
+    _VD_fargs  = 64     // 64 bytes for passing arguments to other Go functions
+    _VD_saves  = 40     // 40 bytes for saving the registers before CALL instructions
+    _VD_locals = 88     // 88 bytes for local variables
+)
+
+const (
+    _VD_offs = _VD_fargs + _VD_saves + _VD_locals
+    _VD_size = _VD_offs + 8     // 8 bytes for the parent frame pointer
+)
+
+var (
+    _VAR_ss = _VAR_ss_Vt
+    _VAR_df = jit.Ptr(_SP, _VD_fargs + _VD_saves)
+)
+
+var (
+    _VAR_ss_Vt = jit.Ptr(_SP, _VD_fargs + _VD_saves + 8)
+    _VAR_ss_Dv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 16)
+    _VAR_ss_Iv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 24)
+    _VAR_ss_Ep = jit.Ptr(_SP, _VD_fargs + _VD_saves + 32)
+    _VAR_ss_Db = jit.Ptr(_SP, _VD_fargs + _VD_saves + 40)
+    _VAR_ss_Dc = jit.Ptr(_SP, _VD_fargs + _VD_saves + 48)
+)
+
+var (
+    _VAR_cs_LR = jit.Ptr(_SP, _VD_fargs + _VD_saves + 56)
+    _VAR_cs_p = jit.Ptr(_SP, _VD_fargs + _VD_saves + 64)
+    _VAR_cs_n = jit.Ptr(_SP, _VD_fargs + _VD_saves + 72)
+    _VAR_cs_d = jit.Ptr(_SP, _VD_fargs + _VD_saves + 80)
+)
+
+type _ValueDecoder struct {
+    jit.BaseAssembler
+}
+
+func (self *_ValueDecoder) build() uintptr {
+    self.Init(self.compile)
+    return *(*uintptr)(self.Load("decode_value", _VD_size, _VD_args, argPtrs_generic, localPtrs_generic))
+}
+
+/** Function Calling Helpers **/
+
+func (self *_ValueDecoder) save(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _VD_saves / 8 - 1 {
+            panic("too many registers to save")
+        } else {
+            self.Emit("MOVQ", v, jit.Ptr(_SP, _VD_fargs + int64(i) * 8))
+        }
+    }
+}
+
+func (self *_ValueDecoder) load(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _VD_saves / 8 - 1 {
+            panic("too many registers to load")
+        } else {
+            self.Emit("MOVQ", jit.Ptr(_SP, _VD_fargs + int64(i) * 8), v)
+        }
+    }
+}
+
+func (self *_ValueDecoder) call(fn obj.Addr) {
+    self.Emit("MOVQ", fn, _AX)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _AX)      // CALL AX
+}
+
+func (self *_ValueDecoder) call_go(fn obj.Addr) {
+    self.save(_REG_go...)   // SAVE $REG_go
+    self.call(fn)           // CALL ${fn}
+    self.load(_REG_go...)   // LOAD $REG_go
+}
+
+/** Decoder Assembler **/
+
+const (
+    _S_val = iota + 1
+    _S_arr
+    _S_arr_0
+    _S_obj
+    _S_obj_0
+    _S_obj_delim
+    _S_obj_sep
+)
+
+const (
+    _S_omask_key = (1 << _S_obj_0) | (1 << _S_obj_sep)
+    _S_omask_end = (1 << _S_obj_0) | (1 << _S_obj)
+    _S_vmask = (1 << _S_val) | (1 << _S_arr_0)
+)
+
+const (
+    _A_init_len = 1
+    _A_init_cap = 16
+)
+
+const (
+    _ST_Sp = 0
+    _ST_Vt = _PtrBytes
+    _ST_Vp = _PtrBytes * (types.MAX_RECURSE + 1)
+)
+
+var (
+    _V_true  = jit.Imm(int64(pbool(true)))
+    _V_false = jit.Imm(int64(pbool(false)))
+    _F_value = jit.Imm(int64(native.S_value))
+)
+
+var (
+    _V_max     = jit.Imm(int64(types.V_MAX))
+    _E_eof     = jit.Imm(int64(types.ERR_EOF))
+    _E_invalid = jit.Imm(int64(types.ERR_INVALID_CHAR))
+    _E_recurse = jit.Imm(int64(types.ERR_RECURSE_EXCEED_MAX))
+)
+
+var (
+    _F_convTslice    = jit.Func(convTslice)
+    _F_convTstring   = jit.Func(convTstring)
+    _F_invalid_vtype = jit.Func(invalid_vtype)
+)
+
+var (
+    _T_map     = jit.Type(reflect.TypeOf((map[string]interface{})(nil)))
+    _T_bool    = jit.Type(reflect.TypeOf(false))
+    _T_int64   = jit.Type(reflect.TypeOf(int64(0)))
+    _T_eface   = jit.Type(reflect.TypeOf((*interface{})(nil)).Elem())
+    _T_slice   = jit.Type(reflect.TypeOf(([]interface{})(nil)))
+    _T_string  = jit.Type(reflect.TypeOf(""))
+    _T_number  = jit.Type(reflect.TypeOf(json.Number("")))
+    _T_float64 = jit.Type(reflect.TypeOf(float64(0)))
+)
+
+var _R_tab = map[int]string {
+    '[': "_decode_V_ARRAY",
+    '{': "_decode_V_OBJECT",
+    ':': "_decode_V_KEY_SEP",
+    ',': "_decode_V_ELEM_SEP",
+    ']': "_decode_V_ARRAY_END",
+    '}': "_decode_V_OBJECT_END",
+}
+
+func (self *_ValueDecoder) compile() {
+    self.Emit("SUBQ", jit.Imm(_VD_size), _SP)       // SUBQ $_VD_size, SP
+    self.Emit("MOVQ", _BP, jit.Ptr(_SP, _VD_offs))  // MOVQ BP, _VD_offs(SP)
+    self.Emit("LEAQ", jit.Ptr(_SP, _VD_offs), _BP)  // LEAQ _VD_offs(SP), BP
+
+    /* initialize the state machine */
+    self.Emit("XORL", _CX, _CX)                                 // XORL CX, CX
+    self.Emit("MOVQ", _DF, _VAR_df)                             // MOVQ DF, df
+    /* initialize digital buffer first */
+    self.Emit("MOVQ", jit.Imm(_MaxDigitNums), _VAR_ss_Dc)       // MOVQ $_MaxDigitNums, ss.Dcap
+    self.Emit("LEAQ", jit.Ptr(_ST, _DbufOffset), _AX)           // LEAQ _DbufOffset(ST), AX
+    self.Emit("MOVQ", _AX, _VAR_ss_Db)                          // MOVQ AX, ss.Dbuf
+    /* add ST offset */
+    self.Emit("ADDQ", jit.Imm(_FsmOffset), _ST)                 // ADDQ _FsmOffset, _ST
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                // MOVQ CX, ST.Sp
+    self.WriteRecNotAX(0, _VP, jit.Ptr(_ST, _ST_Vp), false)                // MOVQ VP, ST.Vp[0]
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Ptr(_ST, _ST_Vt))    // MOVQ _S_val, ST.Vt[0]
+    self.Sjmp("JMP" , "_next")                                  // JMP  _next
+
+    /* set the value from previous round */
+    self.Link("_set_value")                                 // _set_value:
+    self.Emit("MOVL" , jit.Imm(_S_vmask), _DX)              // MOVL  _S_vmask, DX
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)           // MOVQ  ST.Sp, CX
+    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)   // MOVQ  ST.Vt[CX], AX
+    self.Emit("BTQ"  , _AX, _DX)                            // BTQ   AX, DX
+    self.Sjmp("JNC"  , "_vtype_error")                      // JNC   _vtype_error
+    self.Emit("XORL" , _SI, _SI)                            // XORL  SI, SI
+    self.Emit("SUBQ" , jit.Imm(1), jit.Ptr(_ST, _ST_Sp))    // SUBQ  $1, ST.Sp
+    self.Emit("XCHGQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)   // XCHGQ ST.Vp[CX], SI
+    self.Emit("MOVQ" , _R8, jit.Ptr(_SI, 0))                // MOVQ  R8, (SI)
+    self.WriteRecNotAX(1, _R9, jit.Ptr(_SI, 8), false)           // MOVQ  R9, 8(SI)
+
+    /* check for value stack */
+    self.Link("_next")                              // _next:
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _AX)   // MOVQ  ST.Sp, AX
+    self.Emit("TESTQ", _AX, _AX)                    // TESTQ AX, AX
+    self.Sjmp("JS"   , "_return")                   // JS    _return
+
+    /* fast path: test up to 4 characters manually */
+    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+    self.Emit("MOVQ"   , jit.Imm(_BM_space), _DX)       // MOVQ    _BM_space, DX
+    self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+    self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
+    self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
+    self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
+    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+
+    /* at least 1 to 3 spaces */
+    for i := 0; i < 3; i++ {
+        self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+        self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+        self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+        self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+        self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
+        self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
+        self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
+        self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+    }
+
+    /* at least 4 spaces */
+    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+
+    /* fast path: use lookup table to select decoder */
+    self.Link("_decode_fast")                           // _decode_fast:
+    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ    ?(PC), DI
+    self.Sref("_decode_tab", 4)                         // ....    &_decode_tab
+    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, 0), _AX)  // MOVLQSX (DI)(AX*4), AX
+    self.Emit("TESTQ"  , _AX, _AX)                      // TESTQ   AX, AX
+    self.Sjmp("JZ"     , "_decode_native")              // JZ      _decode_native
+    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+    self.Emit("ADDQ"   , _DI, _AX)                      // ADDQ    DI, AX
+    self.Rjmp("JMP"    , _AX)                           // JMP     AX
+
+    /* decode with native decoder */
+    self.Link("_decode_native")         // _decode_native:
+    self.Emit("MOVQ", _IP, _DI)         // MOVQ IP, DI
+    self.Emit("MOVQ", _IL, _SI)         // MOVQ IL, SI
+    self.Emit("MOVQ", _IC, _DX)         // MOVQ IC, DX
+    self.Emit("LEAQ", _VAR_ss, _CX)     // LEAQ ss, CX
+    self.Emit("MOVQ", _VAR_df, _R8)     // MOVQ $df, R8
+    self.Emit("BTSQ", jit.Imm(_F_allow_control), _R8)  // ANDQ $1<<_F_allow_control, R8
+    self.call(_F_value)                 // CALL value
+    self.Emit("MOVQ", _AX, _IC)         // MOVQ AX, IC
+
+    /* check for errors */
+    self.Emit("MOVQ" , _VAR_ss_Vt, _AX)     // MOVQ  ss.Vt, AX
+    self.Emit("TESTQ", _AX, _AX)            // TESTQ AX, AX
+    self.Sjmp("JS"   , "_parsing_error")
+    self.Sjmp("JZ"   , "_invalid_vtype")    // JZ    _invalid_vtype
+    self.Emit("CMPQ" , _AX, _V_max)         // CMPQ  AX, _V_max
+    self.Sjmp("JA"   , "_invalid_vtype")    // JA    _invalid_vtype
+
+    /* jump table selector */
+    self.Byte(0x48, 0x8d, 0x3d)                             // LEAQ    ?(PC), DI
+    self.Sref("_switch_table", 4)                           // ....    &_switch_table
+    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, -4), _AX)     // MOVLQSX -4(DI)(AX*4), AX
+    self.Emit("ADDQ"   , _DI, _AX)                          // ADDQ    DI, AX
+    self.Rjmp("JMP"    , _AX)                               // JMP     AX
+
+    /** V_EOF **/
+    self.Link("_decode_V_EOF")          // _decode_V_EOF:
+    self.Emit("MOVL", _E_eof, _EP)      // MOVL _E_eof, EP
+    self.Sjmp("JMP" , "_error")         // JMP  _error
+
+    /** V_NULL **/
+    self.Link("_decode_V_NULL")                 // _decode_V_NULL:
+    self.Emit("XORL", _R8, _R8)                 // XORL R8, R8
+    self.Emit("XORL", _R9, _R9)                 // XORL R9, R9
+    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_TRUE **/
+    self.Link("_decode_V_TRUE")                 // _decode_V_TRUE:
+    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
+    // TODO: maybe modified by users?
+    self.Emit("MOVQ", _V_true, _R9)             // MOVQ _V_true, R9 
+    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_FALSE **/
+    self.Link("_decode_V_FALSE")                // _decode_V_FALSE:
+    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
+    self.Emit("MOVQ", _V_false, _R9)            // MOVQ _V_false, R9
+    self.Emit("LEAQ", jit.Ptr(_IC, -5), _DI)    // LEAQ -5(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_ARRAY **/
+    self.Link("_decode_V_ARRAY")                            // _decode_V_ARRAY
+    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)               // MOVL _S_vmask, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DX)                             // BTQ  AX, DX
+    self.Sjmp("JNC" , "_invalid_char")                      // JNC  _invalid_char
+
+    /* create a new array */
+    self.Emit("MOVQ", _T_eface, _AX)                            // MOVQ    _T_eface, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))                     // MOVQ    AX, (SP)
+    self.Emit("MOVQ", jit.Imm(_A_init_len), jit.Ptr(_SP, 8))    // MOVQ    _A_init_len, 8(SP)
+    self.Emit("MOVQ", jit.Imm(_A_init_cap), jit.Ptr(_SP, 16))   // MOVQ    _A_init_cap, 16(SP)
+    self.call_go(_F_makeslice)                                  // CALL_GO runtime.makeslice
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), _DX)                    // MOVQ    24(SP), DX
+
+    /* pack into an interface */
+    self.Emit("MOVQ", _DX, jit.Ptr(_SP, 0))                     // MOVQ    DX, (SP)
+    self.Emit("MOVQ", jit.Imm(_A_init_len), jit.Ptr(_SP, 8))    // MOVQ    _A_init_len, 8(SP)
+    self.Emit("MOVQ", jit.Imm(_A_init_cap), jit.Ptr(_SP, 16))   // MOVQ    _A_init_cap, 16(SP)
+    self.call_go(_F_convTslice)                                 // CALL_GO runtime.convTslice
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), _R8)                    // MOVQ    24(SP), R8
+
+    /* replace current state with an array */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Imm(_S_arr), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_arr, ST.Vt[CX]
+    self.Emit("MOVQ", _T_slice, _AX)                                    // MOVQ _T_slice, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 0))                             // MOVQ AX, (SI)
+    self.WriteRecNotAX(2, _R8, jit.Ptr(_SI, 8), false)                            // MOVQ R8, 8(SI)
+
+    /* add a new slot for the first element */
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
+    self.Emit("MOVQ", jit.Ptr(_R8, 0), _AX)                             // MOVQ (R8), AX
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
+    self.WritePtrAX(3, jit.Sib(_ST, _CX, 8, _ST_Vp), false)                // MOVQ AX, ST.Vp[CX]
+    self.Emit("MOVQ", jit.Imm(_S_arr_0), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_arr_0, ST.Vt[CX]
+    self.Sjmp("JMP" , "_next")                                          // JMP  _next
+
+    /** V_OBJECT **/
+    self.Link("_decode_V_OBJECT")                                       // _decode_V_OBJECT:
+    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)                           // MOVL    _S_vmask, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                // MOVQ    ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DX)                                         // BTQ     AX, DX
+    self.Sjmp("JNC" , "_invalid_char")                                  // JNC     _invalid_char
+    self.call_go(_F_makemap_small)                                      // CALL_GO runtime.makemap_small
+    self.Emit("MOVQ", jit.Ptr(_SP, 0), _AX)                             // MOVQ    (SP), AX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
+    self.Emit("MOVQ", jit.Imm(_S_obj_0), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ    _S_obj, ST.Vt[CX]
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ    ST.Vp[CX], SI
+    self.Emit("MOVQ", _T_map, _DX)                                      // MOVQ    _T_map, DX
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 0))                             // MOVQ    DX, (SI)
+    self.WritePtrAX(4, jit.Ptr(_SI, 8), false)                             // MOVQ    AX, 8(SI)
+    self.Sjmp("JMP" , "_next")                                          // JMP     _next
+
+    /** V_STRING **/
+    self.Link("_decode_V_STRING")       // _decode_V_STRING:
+    self.Emit("MOVQ", _VAR_ss_Iv, _CX)  // MOVQ ss.Iv, CX
+    self.Emit("MOVQ", _IC, _AX)         // MOVQ IC, AX
+    self.Emit("SUBQ", _CX, _AX)         // SUBQ CX, AX
+
+    /* check for escapes */
+    self.Emit("CMPQ", _VAR_ss_Ep, jit.Imm(-1))          // CMPQ ss.Ep, $-1
+    self.Sjmp("JNE" , "_unquote")                       // JNE  _unquote
+    self.Emit("SUBQ", jit.Imm(1), _AX)                  // SUBQ $1, AX
+    self.Emit("LEAQ", jit.Sib(_IP, _CX, 1, 0), _R8)     // LEAQ (IP)(CX), R8
+    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ (PC), DI
+    self.Sref("_copy_string_end", 4)
+    self.Emit("BTQ", jit.Imm(_F_copy_string), _VAR_df)
+    self.Sjmp("JC", "copy_string")
+    self.Link("_copy_string_end")                                 
+    self.Emit("XORL", _DX, _DX)                             // XORL DX, DX
+    /* strings with no escape sequences */
+    self.Link("_noescape")                                  // _noescape:
+    self.Emit("MOVL", jit.Imm(_S_omask_key), _DI)               // MOVL _S_omask, DI
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _SI)    // MOVQ ST.Vt[CX], SI
+    self.Emit("BTQ" , _SI, _DI)                             // BTQ  SI, DI
+    self.Sjmp("JC"  , "_object_key")                        // JC   _object_key
+
+    /* check for pre-packed strings, avoid 1 allocation */
+    self.Emit("TESTQ", _DX, _DX)                // TESTQ   DX, DX
+    self.Sjmp("JNZ"  , "_packed_str")           // JNZ     _packed_str
+    self.Emit("MOVQ" , _R8, jit.Ptr(_SP, 0))    // MOVQ    R8, (SP)
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 8))    // MOVQ    AX, 8(SP)
+    self.call_go(_F_convTstring)                // CALL_GO runtime.convTstring
+    self.Emit("MOVQ" , jit.Ptr(_SP, 16), _R9)   // MOVQ    16(SP), R9
+
+    /* packed string already in R9 */
+    self.Link("_packed_str")            // _packed_str:
+    self.Emit("MOVQ", _T_string, _R8)   // MOVQ _T_string, R8
+    self.Emit("MOVQ", _VAR_ss_Iv, _DI)  // MOVQ ss.Iv, DI
+    self.Emit("SUBQ", jit.Imm(1), _DI)  // SUBQ $1, DI
+    self.Sjmp("JMP" , "_set_value")     // JMP  _set_value
+
+    /* the string is an object key, get the map */
+    self.Link("_object_key")
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+
+    /* add a new delimiter */
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                      // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                      // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow")                                    // JA   _stack_overflow
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                            // MOVQ CX, ST.Sp
+    self.Emit("MOVQ", jit.Imm(_S_obj_delim), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_obj_delim, ST.Vt[CX]
+
+    /* add a new slot int the map */
+    self.Emit("MOVQ", _T_map, _DX)                      // MOVQ    _T_map, DX
+    self.Emit("MOVQ", _DX, jit.Ptr(_SP, 0))             // MOVQ    DX, (SP)
+    self.Emit("MOVQ", _SI, jit.Ptr(_SP, 8))             // MOVQ    SI, 8(SP)
+    self.Emit("MOVQ", _R8, jit.Ptr(_SP, 16))            // MOVQ    R9, 16(SP)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 24))            // MOVQ    AX, 24(SP)
+    self.call_go(_F_mapassign_faststr)                  // CALL_GO runtime.mapassign_faststr
+    self.Emit("MOVQ", jit.Ptr(_SP, 32), _AX)            // MOVQ    32(SP), AX
+
+    /* add to the pointer stack */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                 // MOVQ ST.Sp, CX
+    self.WritePtrAX(6, jit.Sib(_ST, _CX, 8, _ST_Vp), false)    // MOVQ AX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                                   // JMP  _next
+
+    /* allocate memory to store the string header and unquoted result */
+    self.Link("_unquote")                               // _unquote:
+    self.Emit("ADDQ", jit.Imm(15), _AX)                 // ADDQ    $15, AX
+    self.Emit("MOVQ", _T_byte, _CX)                     // MOVQ    _T_byte, CX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))             // MOVQ    AX, (SP)
+    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 8))             // MOVQ    CX, 8(SP)
+    self.Emit("MOVB", jit.Imm(0), jit.Ptr(_SP, 16))     // MOVB    $0, 16(SP)
+    self.call_go(_F_mallocgc)                           // CALL_GO runtime.mallocgc
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), _R9)            // MOVQ    24(SP), R9
+
+    /* prepare the unquoting parameters */
+    self.Emit("MOVQ" , _VAR_ss_Iv, _CX)                         // MOVQ  ss.Iv, CX
+    self.Emit("LEAQ" , jit.Sib(_IP, _CX, 1, 0), _DI)            // LEAQ  (IP)(CX), DI
+    self.Emit("NEGQ" , _CX)                                     // NEGQ  CX
+    self.Emit("LEAQ" , jit.Sib(_IC, _CX, 1, -1), _SI)           // LEAQ  -1(IC)(CX), SI
+    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _DX)                   // LEAQ  16(R8), DX
+    self.Emit("LEAQ" , _VAR_ss_Ep, _CX)                         // LEAQ  ss.Ep, CX
+    self.Emit("XORL" , _R8, _R8)                                // XORL  R8, R8
+    self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _VAR_df)        // BTQ   ${_F_disable_urc}, fv
+    self.Emit("SETCC", _R8)                                     // SETCC R8
+    self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _R8)   // SHLQ  ${types.B_UNICODE_REPLACE}, R8
+
+    /* unquote the string, with R9 been preserved */
+    self.save(_R9)                                      // SAVE R9
+    self.call(_F_unquote)                               // CALL unquote
+    self.load(_R9)                                      // LOAD R9
+
+    /* check for errors */
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
+    self.Sjmp("JS"   , "_unquote_error")        // JS    _unquote_error
+    self.Emit("MOVL" , jit.Imm(1), _DX)         // MOVL  $1, DX
+    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _R8)   // ADDQ  $16, R8
+    self.Emit("MOVQ" , _R8, jit.Ptr(_R9, 0))    // MOVQ  R8, (R9)
+    self.Emit("MOVQ" , _AX, jit.Ptr(_R9, 8))    // MOVQ  AX, 8(R9)
+    self.Sjmp("JMP"  , "_noescape")             // JMP   _noescape
+
+    /** V_DOUBLE **/
+    self.Link("_decode_V_DOUBLE")                           // _decode_V_DOUBLE:
+    self.Emit("BTQ"  , jit.Imm(_F_use_number), _VAR_df)     // BTQ     _F_use_number, df
+    self.Sjmp("JC"   , "_use_number")                       // JC      _use_number
+    self.Emit("MOVSD", _VAR_ss_Dv, _X0)                     // MOVSD   ss.Dv, X0
+    self.Sjmp("JMP"  , "_use_float64")                      // JMP     _use_float64
+
+    /** V_INTEGER **/
+    self.Link("_decode_V_INTEGER")                          // _decode_V_INTEGER:
+    self.Emit("BTQ"     , jit.Imm(_F_use_number), _VAR_df)  // BTQ      _F_use_number, df
+    self.Sjmp("JC"      , "_use_number")                    // JC       _use_number
+    self.Emit("BTQ"     , jit.Imm(_F_use_int64), _VAR_df)   // BTQ      _F_use_int64, df
+    self.Sjmp("JC"      , "_use_int64")                     // JC       _use_int64
+    self.Emit("MOVQ"    , _VAR_ss_Iv, _AX)                  // MOVQ     ss.Iv, AX
+    self.Emit("CVTSQ2SD", _AX, _X0)                         // CVTSQ2SD AX, X0
+
+    /* represent numbers as `float64` */
+    self.Link("_use_float64")                   // _use_float64:
+    self.Emit("MOVSD", _X0, jit.Ptr(_SP, 0))    // MOVSD   X0, (SP)
+    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
+    self.Emit("MOVQ" , _T_float64, _R8)         // MOVQ    _T_float64, R8
+    self.Emit("MOVQ" , jit.Ptr(_SP, 8), _R9)    // MOVQ    8(SP), R9
+    self.Emit("MOVQ" , _VAR_ss_Ep, _DI)         // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP"  , "_set_value")            // JMP     _set_value
+
+    /* represent numbers as `json.Number` */
+    self.Link("_use_number")                            // _use_number
+    self.Emit("MOVQ", _VAR_ss_Ep, _AX)                  // MOVQ    ss.Ep, AX
+    self.Emit("LEAQ", jit.Sib(_IP, _AX, 1, 0), _SI)     // LEAQ    (IP)(AX), SI
+    self.Emit("MOVQ", _IC, _CX)                         // MOVQ    IC, CX
+    self.Emit("SUBQ", _AX, _CX)                         // SUBQ    AX, CX
+    self.Emit("MOVQ", _SI, jit.Ptr(_SP, 0))             // MOVQ    SI, (SP)
+    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 8))             // MOVQ    CX, 8(SP)
+    self.call_go(_F_convTstring)                        // CALL_GO runtime.convTstring
+    self.Emit("MOVQ", _T_number, _R8)                   // MOVQ    _T_number, R8
+    self.Emit("MOVQ", jit.Ptr(_SP, 16), _R9)            // MOVQ    16(SP), R9
+    self.Emit("MOVQ", _VAR_ss_Ep, _DI)                  // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP" , "_set_value")                     // JMP     _set_value
+
+    /* represent numbers as `int64` */
+    self.Link("_use_int64")                     // _use_int64:
+    self.Emit("MOVQ", _VAR_ss_Iv, _AX)          // MOVQ    ss.Iv, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))     // MOVQ    AX, (SP)
+    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
+    self.Emit("MOVQ", _T_int64, _R8)            // MOVQ    _T_int64, R8
+    self.Emit("MOVQ", jit.Ptr(_SP, 8), _R9)     // MOVQ    8(SP), R9
+    self.Emit("MOVQ", _VAR_ss_Ep, _DI)          // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP" , "_set_value")             // JMP     _set_value
+
+    /** V_KEY_SEP **/
+    self.Link("_decode_V_KEY_SEP")                                          // _decode_V_KEY_SEP:
+    // self.Byte(0xcc)
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                    // MOVQ ST.Vt[CX], AX
+    self.Emit("CMPQ", _AX, jit.Imm(_S_obj_delim))                           // CMPQ AX, _S_obj_delim
+    self.Sjmp("JNE" , "_invalid_char")                                      // JNE  _invalid_char
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))        // MOVQ _S_val, ST.Vt[CX]
+    self.Emit("MOVQ", jit.Imm(_S_obj), jit.Sib(_ST, _CX, 8, _ST_Vt - 8))    // MOVQ _S_obj, ST.Vt[CX - 1]
+    self.Sjmp("JMP" , "_next")                                              // JMP  _next
+
+    /** V_ELEM_SEP **/
+    self.Link("_decode_V_ELEM_SEP")                             // _decode_V_ELEM_SEP:
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ     ST.Sp, CX
+    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ     ST.Vt[CX], AX
+    self.Emit("CMPQ" , _AX, jit.Imm(_S_arr))                 // CMPQ     _AX, _S_arr
+    self.Sjmp("JE"   , "_array_sep")                         // JZ       _next
+    self.Emit("CMPQ" , _AX, jit.Imm(_S_obj))                 // CMPQ     _AX, _S_arr
+    self.Sjmp("JNE"  , "_invalid_char")                      // JNE      _invalid_char
+    self.Emit("MOVQ" , jit.Imm(_S_obj_sep), jit.Sib(_ST, _CX, 8, _ST_Vt))
+    self.Sjmp("JMP"  , "_next")                              // JMP      _next
+
+    /* arrays */
+    self.Link("_array_sep")
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _DX)                 // MOVQ 8(SI), DX
+    self.Emit("CMPQ", _DX, jit.Ptr(_SI, 16))                // CMPQ DX, 16(SI)
+    self.Sjmp("JAE" , "_array_more")                        // JAE  _array_more
+
+    /* add a slot for the new element */
+    self.Link("_array_append")                                          // _array_append:
+    self.Emit("ADDQ", jit.Imm(1), jit.Ptr(_SI, 8))                      // ADDQ $1, 8(SI)
+    self.Emit("MOVQ", jit.Ptr(_SI, 0), _SI)                             // MOVQ (SI), SI
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow") 
+    self.Emit("SHLQ", jit.Imm(1), _DX)                                  // SHLQ $1, DX
+    self.Emit("LEAQ", jit.Sib(_SI, _DX, 8, 0), _SI)                     // LEAQ (SI)(DX*8), SI
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
+    self.WriteRecNotAX(7 , _SI, jit.Sib(_ST, _CX, 8, _ST_Vp), false)           // MOVQ SI, ST.Vp[CX]
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_val, ST.Vt[CX}
+    self.Sjmp("JMP" , "_next")                                          // JMP  _next
+
+    /** V_ARRAY_END **/
+    self.Link("_decode_V_ARRAY_END")                        // _decode_V_ARRAY_END:
+    self.Emit("XORL", _DX, _DX)                             // XORL DX, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("CMPQ", _AX, jit.Imm(_S_arr_0))               // CMPQ AX, _S_arr_0
+    self.Sjmp("JE"  , "_first_item")                        // JE   _first_item
+    self.Emit("CMPQ", _AX, jit.Imm(_S_arr))                 // CMPQ AX, _S_arr
+    self.Sjmp("JNE" , "_invalid_char")                      // JNE  _invalid_char
+    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ DX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                              // JMP  _next
+
+    /* first element of an array */
+    self.Link("_first_item")                                    // _first_item:
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                // MOVQ ST.Sp, CX
+    self.Emit("SUBQ", jit.Imm(2), jit.Ptr(_ST, _ST_Sp))         // SUBQ $2, ST.Sp
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp - 8), _SI)    // MOVQ ST.Vp[CX - 1], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                     // MOVQ 8(SI), SI
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp - 8))    // MOVQ DX, ST.Vp[CX - 1]
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))        // MOVQ DX, ST.Vp[CX]
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                     // MOVQ DX, 8(SI)
+    self.Sjmp("JMP" , "_next")                                  // JMP  _next
+
+    /** V_OBJECT_END **/
+    self.Link("_decode_V_OBJECT_END")                       // _decode_V_OBJECT_END:
+    self.Emit("MOVL", jit.Imm(_S_omask_end), _DX)           // MOVL _S_omask, DI
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DX)                
+    self.Sjmp("JNC" , "_invalid_char")                      // JNE  _invalid_char
+    self.Emit("XORL", _AX, _AX)                             // XORL AX, AX
+    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
+    self.Emit("MOVQ", _AX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ AX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                              // JMP  _next
+
+    /* return from decoder */
+    self.Link("_return")                            // _return:
+    self.Emit("XORL", _EP, _EP)                     // XORL EP, EP
+    self.Emit("MOVQ", _EP, jit.Ptr(_ST, _ST_Vp))    // MOVQ EP, ST.Vp[0]
+    self.Link("_epilogue")                          // _epilogue:
+    self.Emit("SUBQ", jit.Imm(_FsmOffset), _ST)     // SUBQ _FsmOffset, _ST
+    self.Emit("MOVQ", jit.Ptr(_SP, _VD_offs), _BP)  // MOVQ _VD_offs(SP), BP
+    self.Emit("ADDQ", jit.Imm(_VD_size), _SP)       // ADDQ $_VD_size, SP
+    self.Emit("RET")                                // RET
+
+    /* array expand */
+    self.Link("_array_more")                    // _array_more:
+    self.Emit("MOVQ" , _T_eface, _AX)           // MOVQ    _T_eface, AX
+    self.Emit("MOVOU", jit.Ptr(_SI, 0), _X0)    // MOVOU   (SI), X0
+    self.Emit("MOVQ" , jit.Ptr(_SI, 16), _DX)   // MOVQ    16(SI), DX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))    // MOVQ    AX, (SP)
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 8))    // MOVOU   X0, 8(SP)
+    self.Emit("MOVQ" , _DX, jit.Ptr(_SP, 24))   // MOVQ    DX, 24(SP)
+    self.Emit("SHLQ" , jit.Imm(1), _DX)         // SHLQ    $1, DX
+    self.Emit("MOVQ" , _DX, jit.Ptr(_SP, 32))   // MOVQ    DX, 32(SP)
+    self.call_go(_F_growslice)                  // CALL_GO runtime.growslice
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _DI)   // MOVOU   40(SP), DI
+    self.Emit("MOVQ" , jit.Ptr(_SP, 48), _DX)   // MOVOU   48(SP), DX
+    self.Emit("MOVQ" , jit.Ptr(_SP, 56), _AX)   // MOVQ    56(SP), AX
+
+    /* update the slice */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                 // MOVQ DX, 8(SI)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 16))                // MOVQ AX, 16(AX)
+    self.WriteRecNotAX(8 , _DI, jit.Ptr(_SI, 0), false)                 // MOVQ R10, (SI)
+    self.Sjmp("JMP" , "_array_append")                      // JMP  _array_append
+
+    /* copy string */
+    self.Link("copy_string")  // pointer: R8, length: AX, return addr: DI
+    // self.Byte(0xcc)
+    self.Emit("MOVQ", _R8, _VAR_cs_p)
+    self.Emit("MOVQ", _AX, _VAR_cs_n)
+    self.Emit("MOVQ", _DI, _VAR_cs_LR)
+    self.Emit("MOVQ", _T_byte, _R8)
+    self.Emit("MOVQ", _R8, jit.Ptr(_SP, 0))
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 8))
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 16))
+    self.call_go(_F_makeslice)                              
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), _R8)      
+    self.Emit("MOVQ", _R8, _VAR_cs_d)                    
+    self.Emit("MOVQ", _R8, jit.Ptr(_SP, 0))                    
+    self.Emit("MOVQ", _VAR_cs_p, _R8)
+    self.Emit("MOVQ", _R8, jit.Ptr(_SP, 8))
+    self.Emit("MOVQ", _VAR_cs_n, _AX)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 16))
+    self.call_go(_F_memmove)
+    self.Emit("MOVQ", _VAR_cs_d, _R8)
+    self.Emit("MOVQ", _VAR_cs_n, _AX)
+    self.Emit("MOVQ", _VAR_cs_LR, _DI)
+    // self.Byte(0xcc)
+    self.Rjmp("JMP", _DI)
+
+    /* error handlers */
+    self.Link("_stack_overflow")
+    self.Emit("MOVL" , _E_recurse, _EP)         // MOVQ  _E_recurse, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_vtype_error")                   // _vtype_error:
+    self.Emit("MOVQ" , _DI, _IC)                // MOVQ  DI, IC
+    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_invalid_char")                  // _invalid_char:
+    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
+    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_unquote_error")                 // _unquote_error:
+    self.Emit("MOVQ" , _VAR_ss_Iv, _IC)         // MOVQ  ss.Iv, IC
+    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
+    self.Link("_parsing_error")                 // _parsing_error:
+    self.Emit("NEGQ" , _AX)                     // NEGQ  AX
+    self.Emit("MOVQ" , _AX, _EP)                // MOVQ  AX, EP
+    self.Link("_error")                         // _error:
+    self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
+    self.Sjmp("JMP"  , "_epilogue")             // JMP   _epilogue
+
+    /* invalid value type, never returns */
+    self.Link("_invalid_vtype")
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))     // MOVQ AX, (SP)
+    self.call(_F_invalid_vtype)                 // CALL invalid_type
+    self.Emit("UD2")                            // UD2
+
+    /* switch jump table */
+    self.Link("_switch_table")              // _switch_table:
+    self.Sref("_decode_V_EOF", 0)           // SREF &_decode_V_EOF, $0
+    self.Sref("_decode_V_NULL", -4)         // SREF &_decode_V_NULL, $-4
+    self.Sref("_decode_V_TRUE", -8)         // SREF &_decode_V_TRUE, $-8
+    self.Sref("_decode_V_FALSE", -12)       // SREF &_decode_V_FALSE, $-12
+    self.Sref("_decode_V_ARRAY", -16)       // SREF &_decode_V_ARRAY, $-16
+    self.Sref("_decode_V_OBJECT", -20)      // SREF &_decode_V_OBJECT, $-20
+    self.Sref("_decode_V_STRING", -24)      // SREF &_decode_V_STRING, $-24
+    self.Sref("_decode_V_DOUBLE", -28)      // SREF &_decode_V_DOUBLE, $-28
+    self.Sref("_decode_V_INTEGER", -32)     // SREF &_decode_V_INTEGER, $-32
+    self.Sref("_decode_V_KEY_SEP", -36)     // SREF &_decode_V_KEY_SEP, $-36
+    self.Sref("_decode_V_ELEM_SEP", -40)    // SREF &_decode_V_ELEM_SEP, $-40
+    self.Sref("_decode_V_ARRAY_END", -44)   // SREF &_decode_V_ARRAY_END, $-44
+    self.Sref("_decode_V_OBJECT_END", -48)  // SREF &_decode_V_OBJECT_END, $-48
+
+    /* fast character lookup table */
+    self.Link("_decode_tab")        // _decode_tab:
+    self.Sref("_decode_V_EOF", 0)   // SREF &_decode_V_EOF, $0
+
+    /* generate rest of the tabs */
+    for i := 1; i < 256; i++ {
+        if to, ok := _R_tab[i]; ok {
+            self.Sref(to, -int64(i) * 4)
+        } else {
+            self.Byte(0x00, 0x00, 0x00, 0x00)
+        }
+    }
+}
+
+/** Generic Decoder **/
+
+var (
+    _subr_decode_value = new(_ValueDecoder).build()
+)
+
+//go:nosplit
+func invalid_vtype(vt types.ValueType) {
+    throw(fmt.Sprintf("invalid value type: %d", vt))
+}

vendor/github.com/bytedance/sonic/internal/decoder/generic_stkabi_amd64_test.s

@@ -0,0 +1,37 @@
+// +build go1.16,!go1.17
+
+//
+// Copyright 2021 ByteDance Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·decodeValueStub(SB), NOSPLIT, $0 - 72
+    NO_LOCAL_POINTERS
+    PXOR  X0, X0
+    MOVOU X0, rv+48(FP)
+    MOVQ  st+0(FP), BX
+    MOVQ  sp+8(FP), R12
+    MOVQ  sn+16(FP), R13
+    MOVQ  ic+24(FP), R14
+    MOVQ  vp+32(FP), R15
+    MOVQ  df+40(FP), R10
+    MOVQ  ·_subr_decode_value(SB), AX
+    CALL  AX
+    MOVQ  R14, rp+48(FP)
+    MOVQ  R11, ex+56(FP)
+    RET

vendor/github.com/bytedance/sonic/internal/decoder/pools.go

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `sync`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/caching`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const (
+    _MinSlice = 2
+    _MaxStack = 4096 // 4k slots
+    _MaxStackBytes = _MaxStack * _PtrBytes
+    _MaxDigitNums = types.MaxDigitNums  // used in atof fallback algorithm
+)
+
+const (
+    _PtrBytes   = _PTR_SIZE / 8
+    _FsmOffset  = (_MaxStack + 1) * _PtrBytes
+    _DbufOffset = _FsmOffset + int64(unsafe.Sizeof(types.StateMachine{})) + types.MAX_RECURSE * _PtrBytes
+    _StackSize  = unsafe.Sizeof(_Stack{})
+)
+
+var (
+    stackPool     = sync.Pool{}
+    valueCache    = []unsafe.Pointer(nil)
+    fieldCache    = []*caching.FieldMap(nil)
+    fieldCacheMux = sync.Mutex{}
+    programCache  = caching.CreateProgramCache()
+)
+
+type _Stack struct {
+    sp uintptr
+    sb [_MaxStack]unsafe.Pointer
+    mm types.StateMachine
+    vp [types.MAX_RECURSE]unsafe.Pointer
+    dp [_MaxDigitNums]byte
+}
+
+type _Decoder func(
+    s  string,
+    i  int,
+    vp unsafe.Pointer,
+    sb *_Stack,
+    fv uint64,
+    sv string, // DO NOT pass value to this arguement, since it is only used for local _VAR_sv
+    vk unsafe.Pointer, // DO NOT pass value to this arguement, since it is only used for local _VAR_vk
+) (int, error)
+
+var _KeepAlive struct {
+    s string
+    i int
+    vp unsafe.Pointer
+    sb *_Stack
+    fv uint64
+    sv string
+    vk unsafe.Pointer
+
+    ret int
+    err error
+
+    frame_decoder [_FP_offs]byte
+    frame_generic [_VD_offs]byte
+}
+
+var (
+    argPtrs   = []bool{true, false, false, true, true, false, true, false, true}
+    localPtrs = []bool{}
+)
+
+var (
+    argPtrs_generic   = []bool{true}
+    localPtrs_generic = []bool{}
+)
+
+func newStack() *_Stack {
+    if ret := stackPool.Get(); ret == nil {
+        return new(_Stack)
+    } else {
+        return ret.(*_Stack)
+    }
+}
+
+func resetStack(p *_Stack) {
+    memclrNoHeapPointers(unsafe.Pointer(p), _StackSize)
+}
+
+func freeStack(p *_Stack) {
+    p.sp = 0
+    stackPool.Put(p)
+}
+
+func freezeValue(v unsafe.Pointer) uintptr {
+    valueCache = append(valueCache, v)
+    return uintptr(v)
+}
+
+func freezeFields(v *caching.FieldMap) int64 {
+    fieldCacheMux.Lock()
+    fieldCache = append(fieldCache, v)
+    fieldCacheMux.Unlock()
+    return referenceFields(v)
+}
+
+func referenceFields(v *caching.FieldMap) int64 {
+    return int64(uintptr(unsafe.Pointer(v)))
+}
+
+func makeDecoder(vt *rt.GoType, _ ...interface{}) (interface{}, error) {
+    if pp, err := newCompiler().compile(vt.Pack()); err != nil {
+        return nil, err
+    } else {
+        return newAssembler(pp).Load(), nil
+    }
+}
+
+func findOrCompile(vt *rt.GoType) (_Decoder, error) {
+    if val := programCache.Get(vt); val != nil {
+        return val.(_Decoder), nil
+    } else if ret, err := programCache.Compute(vt, makeDecoder); err == nil {
+        return ret.(_Decoder), nil
+    } else {
+        return nil, err
+    }
+}

vendor/github.com/bytedance/sonic/internal/decoder/primitives.go

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding`
+    `encoding/json`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+func decodeTypedPointer(s string, i int, vt *rt.GoType, vp unsafe.Pointer, sb *_Stack, fv uint64) (int, error) {
+    if fn, err := findOrCompile(vt); err != nil {
+        return 0, err
+    } else {
+        rt.MoreStack(_FP_size + _VD_size + native.MaxFrameSize)
+        ret, err := fn(s, i, vp, sb, fv, "", nil)
+        return ret, err
+    }
+}
+
+func decodeJsonUnmarshaler(vv interface{}, s string) error {
+    return vv.(json.Unmarshaler).UnmarshalJSON(rt.Str2Mem(s))
+}
+
+func decodeTextUnmarshaler(vv interface{}, s string) error {
+    return vv.(encoding.TextUnmarshaler).UnmarshalText(rt.Str2Mem(s))
+}

vendor/github.com/bytedance/sonic/internal/decoder/stream.go

@@ -0,0 +1,257 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `bytes`
+    `io`
+    `sync`
+
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/option`
+)
+
+var (
+    minLeftBufferShift uint = 1
+)
+
+// StreamDecoder is the decoder context object for streaming input.
+type StreamDecoder struct {
+    r       io.Reader
+    buf     []byte
+    scanp   int
+    scanned int64
+    err     error
+    Decoder
+}
+
+var bufPool = sync.Pool{
+    New: func () interface{} {
+        return make([]byte, 0, option.DefaultDecoderBufferSize)
+    },
+}
+
+// NewStreamDecoder adapts to encoding/json.NewDecoder API.
+//
+// NewStreamDecoder returns a new decoder that reads from r.
+func NewStreamDecoder(r io.Reader) *StreamDecoder {
+    return &StreamDecoder{r : r}
+}
+
+// Decode decodes input stream into val with corresponding data. 
+// Redundantly bytes may be read and left in its buffer, and can be used at next call.
+// Either io error from underlying io.Reader (except io.EOF) 
+// or syntax error from data will be recorded and stop subsequently decoding.
+func (self *StreamDecoder) Decode(val interface{}) (err error) {
+    // read more data into buf
+    if self.More() {
+        // println(string(self.buf))
+        var s = self.scanp
+    try_skip:
+        var e = len(self.buf)
+        // println("s:", s, "e:", e, "scanned:",self.scanned, "scanp:",self.scanp, self.buf)
+        var src = rt.Mem2Str(self.buf[s:e])
+        // if len(src) > 5 {
+        //     println(src[:5], src[len(src)-5:])
+        // } else {
+        //     println(src)
+        // }
+        // try skip
+        var x = 0;
+        if y := native.SkipOneFast(&src, &x); y < 0 {
+            if self.readMore()  {
+                // println("more")
+                goto try_skip
+            } else {
+                // println("no more")
+                err = SyntaxError{e, self.s, types.ParsingError(-s), ""}
+                self.setErr(err)
+                return
+            }
+        } else {
+            s = y + s
+            e = x + s
+        }
+        
+        // println("decode: ", s, e)
+        // must copy string here for safety
+        self.Decoder.Reset(string(self.buf[s:e]))
+        err = self.Decoder.Decode(val)
+        if err != nil {
+            self.setErr(err)
+            return 
+        }
+
+        self.scanp = e
+        _, empty := self.scan()
+        if empty {
+            // println("recycle")
+            // no remain valid bytes, thus we just recycle buffer
+            mem := self.buf
+            self.buf = nil
+            bufPool.Put(mem[:0])
+        } else {
+            // println("keep")
+            // remain undecoded bytes, move them onto head
+            n := copy(self.buf, self.buf[self.scanp:])
+            self.buf = self.buf[:n]
+        }   
+
+        self.scanned += int64(self.scanp)
+        self.scanp = 0
+    }    
+
+    return self.err
+}
+
+// InputOffset returns the input stream byte offset of the current decoder position. 
+// The offset gives the location of the end of the most recently returned token and the beginning of the next token.
+func (self *StreamDecoder) InputOffset() int64 {
+    // println("input offset",self.scanned, self.scanp)
+    return self.scanned + int64(self.scanp)
+}
+
+// Buffered returns a reader of the data remaining in the Decoder's buffer. 
+// The reader is valid until the next call to Decode.
+func (self *StreamDecoder) Buffered() io.Reader {
+    return bytes.NewReader(self.buf[self.scanp:])
+}
+
+// More reports whether there is another element in the
+// current array or object being parsed.
+func (self *StreamDecoder) More() bool {
+    if self.err != nil {
+        return false
+    }
+    c, err := self.peek()
+    return err == nil && c != ']' && c != '}'
+}
+
+// More reports whether there is another element in the
+// current array or object being parsed.
+func (self *StreamDecoder) readMore() bool {
+    if self.err != nil {
+        return false
+    }
+
+    var err error
+    var n int
+    for {
+        // Grow buffer if not large enough.
+        l := len(self.buf)
+        realloc(&self.buf)
+
+        n, err = self.r.Read(self.buf[l:cap(self.buf)])
+        self.buf = self.buf[: l+n]
+
+        self.scanp = l
+        _, empty := self.scan()
+        if !empty {
+            return true
+        }
+
+        // buffer has been scanned, now report any error
+        if err != nil  {
+            self.setErr(err)
+            return false
+        }
+    }
+}
+
+func (self *StreamDecoder) setErr(err error) {
+    self.err = err
+    mem := self.buf[:0]
+    self.buf = nil
+    bufPool.Put(mem)
+}
+
+func (self *StreamDecoder) peek() (byte, error) {
+    var err error
+    for {
+        c, empty := self.scan()
+        if !empty {
+            return byte(c), nil
+        }
+        // buffer has been scanned, now report any error
+        if err != nil {
+            self.setErr(err)
+            return 0, err
+        }
+        err = self.refill()
+    }
+}
+
+func (self *StreamDecoder) scan() (byte, bool) {
+    for i := self.scanp; i < len(self.buf); i++ {
+        c := self.buf[i]
+        if isSpace(c) {
+            continue
+        }
+        self.scanp = i
+        return c, false
+    }
+    return 0, true
+}
+
+func isSpace(c byte) bool {
+    return types.SPACE_MASK & (1 << c) != 0
+}
+
+func (self *StreamDecoder) refill() error {
+    // Make room to read more into the buffer.
+    // First slide down data already consumed.
+    if self.scanp > 0 {
+        self.scanned += int64(self.scanp)
+        n := copy(self.buf, self.buf[self.scanp:])
+        self.buf = self.buf[:n]
+        self.scanp = 0
+    }
+
+    // Grow buffer if not large enough.
+    realloc(&self.buf)
+
+    // Read. Delay error for next iteration (after scan).
+    n, err := self.r.Read(self.buf[len(self.buf):cap(self.buf)])
+    self.buf = self.buf[0 : len(self.buf)+n]
+
+    return err
+}
+
+func realloc(buf *[]byte) bool {
+    l := uint(len(*buf))
+    c := uint(cap(*buf))
+    if c == 0 {
+        // println("use pool!")
+       *buf = bufPool.Get().([]byte)
+       return true
+    }
+    if c - l <= c >> minLeftBufferShift {
+        // println("realloc!")
+        e := l+(l>>minLeftBufferShift)
+        if e <= c {
+            e = c*2
+        }
+        tmp := make([]byte, l, e)
+        copy(tmp, *buf)
+        *buf = tmp
+        return true
+    }
+    return false
+}
+

vendor/github.com/bytedance/sonic/internal/decoder/stubs_go116.go

@@ -0,0 +1,111 @@
+// +build go1.16,!go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `unsafe`
+    `reflect`
+
+    _ `github.com/cloudwego/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64decode github.com/cloudwego/base64x._subr__b64decode
+var _subr__b64decode uintptr
+
+// runtime.maxElementSize
+const _max_map_element_size uintptr = 128
+
+func mapfast(vt reflect.Type) bool {
+    return vt.Elem().Size() <= _max_map_element_size
+}
+
+//go:nosplit
+//go:linkname throw runtime.throw
+//goland:noinspection GoUnusedParameter
+func throw(s string)
+
+//go:linkname convT64 runtime.convT64
+//goland:noinspection GoUnusedParameter
+func convT64(v uint64) unsafe.Pointer
+
+//go:linkname convTslice runtime.convTslice
+//goland:noinspection GoUnusedParameter
+func convTslice(v []byte) unsafe.Pointer
+
+//go:linkname convTstring runtime.convTstring
+//goland:noinspection GoUnusedParameter
+func convTstring(v string) unsafe.Pointer
+
+//go:noescape
+//go:linkname memequal runtime.memequal
+//goland:noinspection GoUnusedParameter
+func memequal(a unsafe.Pointer, b unsafe.Pointer, size uintptr) bool
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname mallocgc runtime.mallocgc
+//goland:noinspection GoUnusedParameter
+func mallocgc(size uintptr, typ *rt.GoType, needzero bool) unsafe.Pointer
+
+//go:linkname makeslice runtime.makeslice
+//goland:noinspection GoUnusedParameter
+func makeslice(et *rt.GoType, len int, cap int) unsafe.Pointer
+
+//go:noescape
+//go:linkname growslice runtime.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname makemap_small runtime.makemap_small
+func makemap_small() unsafe.Pointer
+
+//go:linkname mapassign runtime.mapassign
+//goland:noinspection GoUnusedParameter
+func mapassign(t *rt.GoType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
+
+//go:linkname mapassign_fast32 runtime.mapassign_fast32
+//goland:noinspection GoUnusedParameter
+func mapassign_fast32(t *rt.GoType, h unsafe.Pointer, k uint32) unsafe.Pointer
+
+//go:linkname mapassign_fast64 runtime.mapassign_fast64
+//goland:noinspection GoUnusedParameter
+func mapassign_fast64(t *rt.GoType, h unsafe.Pointer, k uint64) unsafe.Pointer
+
+//go:linkname mapassign_fast64ptr runtime.mapassign_fast64ptr
+//goland:noinspection GoUnusedParameter
+func mapassign_fast64ptr(t *rt.GoType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
+
+//go:linkname mapassign_faststr runtime.mapassign_faststr
+//goland:noinspection GoUnusedParameter
+func mapassign_faststr(t *rt.GoType, h unsafe.Pointer, s string) unsafe.Pointer
+
+//go:nosplit
+//go:linkname memclrHasPointers runtime.memclrHasPointers
+//goland:noinspection GoUnusedParameter
+func memclrHasPointers(ptr unsafe.Pointer, n uintptr)
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)

vendor/github.com/bytedance/sonic/internal/decoder/stubs_go120.go

@@ -0,0 +1,111 @@
+// +build go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `unsafe`
+    `reflect`
+
+    _ `github.com/cloudwego/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64decode github.com/cloudwego/base64x._subr__b64decode
+var _subr__b64decode uintptr
+
+// runtime.maxElementSize
+const _max_map_element_size uintptr = 128
+
+func mapfast(vt reflect.Type) bool {
+    return vt.Elem().Size() <= _max_map_element_size
+}
+
+//go:nosplit
+//go:linkname throw runtime.throw
+//goland:noinspection GoUnusedParameter
+func throw(s string)
+
+//go:linkname convT64 runtime.convT64
+//goland:noinspection GoUnusedParameter
+func convT64(v uint64) unsafe.Pointer
+
+//go:linkname convTslice runtime.convTslice
+//goland:noinspection GoUnusedParameter
+func convTslice(v []byte) unsafe.Pointer
+
+//go:linkname convTstring runtime.convTstring
+//goland:noinspection GoUnusedParameter
+func convTstring(v string) unsafe.Pointer
+
+//go:noescape
+//go:linkname memequal runtime.memequal
+//goland:noinspection GoUnusedParameter
+func memequal(a unsafe.Pointer, b unsafe.Pointer, size uintptr) bool
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname mallocgc runtime.mallocgc
+//goland:noinspection GoUnusedParameter
+func mallocgc(size uintptr, typ *rt.GoType, needzero bool) unsafe.Pointer
+
+//go:linkname makeslice runtime.makeslice
+//goland:noinspection GoUnusedParameter
+func makeslice(et *rt.GoType, len int, cap int) unsafe.Pointer
+
+//go:noescape
+//go:linkname growslice reflect.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname makemap_small runtime.makemap_small
+func makemap_small() unsafe.Pointer
+
+//go:linkname mapassign runtime.mapassign
+//goland:noinspection GoUnusedParameter
+func mapassign(t *rt.GoMapType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
+
+//go:linkname mapassign_fast32 runtime.mapassign_fast32
+//goland:noinspection GoUnusedParameter
+func mapassign_fast32(t *rt.GoMapType, h unsafe.Pointer, k uint32) unsafe.Pointer
+
+//go:linkname mapassign_fast64 runtime.mapassign_fast64
+//goland:noinspection GoUnusedParameter
+func mapassign_fast64(t *rt.GoMapType, h unsafe.Pointer, k uint64) unsafe.Pointer
+
+//go:linkname mapassign_fast64ptr runtime.mapassign_fast64ptr
+//goland:noinspection GoUnusedParameter
+func mapassign_fast64ptr(t *rt.GoMapType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
+
+//go:linkname mapassign_faststr runtime.mapassign_faststr
+//goland:noinspection GoUnusedParameter
+func mapassign_faststr(t *rt.GoMapType, h unsafe.Pointer, s string) unsafe.Pointer
+
+//go:nosplit
+//go:linkname memclrHasPointers runtime.memclrHasPointers
+//goland:noinspection GoUnusedParameter
+func memclrHasPointers(ptr unsafe.Pointer, n uintptr)
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)

vendor/github.com/bytedance/sonic/internal/decoder/types.go

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding`
+    `encoding/base64`
+    `encoding/json`
+    `reflect`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var (
+    byteType                = reflect.TypeOf(byte(0))
+    intType                 = reflect.TypeOf(int(0))
+    int8Type                = reflect.TypeOf(int8(0))
+    int16Type               = reflect.TypeOf(int16(0))
+    int32Type               = reflect.TypeOf(int32(0))
+    int64Type               = reflect.TypeOf(int64(0))
+    uintType                = reflect.TypeOf(uint(0))
+    uint8Type               = reflect.TypeOf(uint8(0))
+    uint16Type              = reflect.TypeOf(uint16(0))
+    uint32Type              = reflect.TypeOf(uint32(0))
+    uint64Type              = reflect.TypeOf(uint64(0))
+    float32Type             = reflect.TypeOf(float32(0))
+    float64Type             = reflect.TypeOf(float64(0))
+    stringType              = reflect.TypeOf("")
+    bytesType               = reflect.TypeOf([]byte(nil))
+    jsonNumberType          = reflect.TypeOf(json.Number(""))
+    base64CorruptInputError = reflect.TypeOf(base64.CorruptInputError(0))
+)
+
+var (
+    errorType                   = reflect.TypeOf((*error)(nil)).Elem()
+    jsonUnmarshalerType         = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()
+    encodingTextUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
+)
+
+func rtype(t reflect.Type) (*rt.GoItab, *rt.GoType) {
+    p := (*rt.GoIface)(unsafe.Pointer(&t))
+    return p.Itab, (*rt.GoType)(p.Value)
+}

vendor/github.com/bytedance/sonic/internal/decoder/utils.go

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/loader`
+)
+
+//go:nosplit
+func pbool(v bool) uintptr {
+    return freezeValue(unsafe.Pointer(&v))
+}
+
+//go:nosplit
+func ptodec(p loader.Function) _Decoder {
+    return *(*_Decoder)(unsafe.Pointer(&p))
+}
+
+func assert_eq(v int64, exp int64, msg string) {
+    if v != exp {
+        panic(msg)
+    }
+}

vendor/github.com/bytedance/sonic/internal/encoder/asm_stubs_amd64_go116.go

@@ -0,0 +1,51 @@
+// +build go1.16,!go1.17
+
+// Copyright 2023 CloudWeGo Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package encoder
+
+import (
+    `strconv`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+var (
+    _V_writeBarrier = jit.Imm(int64(_runtime_writeBarrier))
+
+    _F_gcWriteBarrierAX = jit.Func(gcWriteBarrierAX)
+)
+
+func (self *_Assembler) WritePtr(i int, ptr obj.Addr, rec obj.Addr) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _R10)
+    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, _AX)
+    self.xsave(_DI)
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R10)  
+    self.xload(_DI)  
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+

vendor/github.com/bytedance/sonic/internal/encoder/asm_stubs_amd64_go117.go

@@ -0,0 +1,51 @@
+// +build go1.17,!go1.21
+
+// Copyright 2023 CloudWeGo Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package encoder
+
+import (
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+var (
+    _V_writeBarrier = jit.Imm(int64(uintptr(unsafe.Pointer(&_runtime_writeBarrier))))
+
+    _F_gcWriteBarrierAX = jit.Func(gcWriteBarrierAX)
+)
+
+func (self *_Assembler) WritePtr(i int, ptr obj.Addr, rec obj.Addr) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _BX)
+    self.Emit("CMPL", jit.Ptr(_BX, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.xsave(_DI)
+    self.Emit("MOVQ", ptr, _AX)
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _BX)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _BX)  
+    self.xload(_DI)  
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}

vendor/github.com/bytedance/sonic/internal/encoder/asm_stubs_amd64_go121.go

@@ -0,0 +1,50 @@
+// +build go1.21,!go1.23
+
+// Copyright 2023 CloudWeGo Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package encoder
+
+import (
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+var (
+    _V_writeBarrier = jit.Imm(int64(uintptr(unsafe.Pointer(&_runtime_writeBarrier))))
+
+    _F_gcWriteBarrier2 = jit.Func(gcWriteBarrier2)
+)
+
+func (self *_Assembler) WritePtr(i int, ptr obj.Addr, old obj.Addr) {
+    if old.Reg == x86.REG_AX || old.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _BX)
+    self.Emit("CMPL", jit.Ptr(_BX, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.xsave(_SP_q)
+    self.Emit("MOVQ", _F_gcWriteBarrier2, _BX)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _BX)  
+    self.Emit("MOVQ", ptr, jit.Ptr(_SP_q, 0))
+    self.Emit("MOVQ", old, _AX)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP_q, 8))
+    self.xload(_SP_q)  
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, old)
+}

vendor/github.com/bytedance/sonic/internal/encoder/compiler.go

@@ -0,0 +1,885 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `fmt`
+    `reflect`
+    `strconv`
+    `strings`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/resolver`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/option`
+)
+
+type _Op uint8
+
+const (
+    _OP_null _Op = iota + 1
+    _OP_empty_arr
+    _OP_empty_obj
+    _OP_bool
+    _OP_i8
+    _OP_i16
+    _OP_i32
+    _OP_i64
+    _OP_u8
+    _OP_u16
+    _OP_u32
+    _OP_u64
+    _OP_f32
+    _OP_f64
+    _OP_str
+    _OP_bin
+    _OP_quote
+    _OP_number
+    _OP_eface
+    _OP_iface
+    _OP_byte
+    _OP_text
+    _OP_deref
+    _OP_index
+    _OP_load
+    _OP_save
+    _OP_drop
+    _OP_drop_2
+    _OP_recurse
+    _OP_is_nil
+    _OP_is_nil_p1
+    _OP_is_zero_1
+    _OP_is_zero_2
+    _OP_is_zero_4
+    _OP_is_zero_8
+    _OP_is_zero_map
+    _OP_goto
+    _OP_map_iter
+    _OP_map_stop
+    _OP_map_check_key
+    _OP_map_write_key
+    _OP_map_value_next
+    _OP_slice_len
+    _OP_slice_next
+    _OP_marshal
+    _OP_marshal_p
+    _OP_marshal_text
+    _OP_marshal_text_p
+    _OP_cond_set
+    _OP_cond_testc
+)
+
+const (
+    _INT_SIZE = 32 << (^uint(0) >> 63)
+    _PTR_SIZE = 32 << (^uintptr(0) >> 63)
+    _PTR_BYTE = unsafe.Sizeof(uintptr(0))
+)
+
+const (
+    _MAX_ILBUF = 100000     // cutoff at 100k of IL instructions
+    _MAX_FIELDS = 50        // cutoff at 50 fields struct
+)
+
+var _OpNames = [256]string {
+    _OP_null           : "null",
+    _OP_empty_arr      : "empty_arr",
+    _OP_empty_obj      : "empty_obj",
+    _OP_bool           : "bool",
+    _OP_i8             : "i8",
+    _OP_i16            : "i16",
+    _OP_i32            : "i32",
+    _OP_i64            : "i64",
+    _OP_u8             : "u8",
+    _OP_u16            : "u16",
+    _OP_u32            : "u32",
+    _OP_u64            : "u64",
+    _OP_f32            : "f32",
+    _OP_f64            : "f64",
+    _OP_str            : "str",
+    _OP_bin            : "bin",
+    _OP_quote          : "quote",
+    _OP_number         : "number",
+    _OP_eface          : "eface",
+    _OP_iface          : "iface",
+    _OP_byte           : "byte",
+    _OP_text           : "text",
+    _OP_deref          : "deref",
+    _OP_index          : "index",
+    _OP_load           : "load",
+    _OP_save           : "save",
+    _OP_drop           : "drop",
+    _OP_drop_2         : "drop_2",
+    _OP_recurse        : "recurse",
+    _OP_is_nil         : "is_nil",
+    _OP_is_nil_p1      : "is_nil_p1",
+    _OP_is_zero_1      : "is_zero_1",
+    _OP_is_zero_2      : "is_zero_2",
+    _OP_is_zero_4      : "is_zero_4",
+    _OP_is_zero_8      : "is_zero_8",
+    _OP_is_zero_map    : "is_zero_map",
+    _OP_goto           : "goto",
+    _OP_map_iter       : "map_iter",
+    _OP_map_stop       : "map_stop",
+    _OP_map_check_key  : "map_check_key",
+    _OP_map_write_key  : "map_write_key",
+    _OP_map_value_next : "map_value_next",
+    _OP_slice_len      : "slice_len",
+    _OP_slice_next     : "slice_next",
+    _OP_marshal        : "marshal",
+    _OP_marshal_p      : "marshal_p",
+    _OP_marshal_text   : "marshal_text",
+    _OP_marshal_text_p : "marshal_text_p",
+    _OP_cond_set       : "cond_set",
+    _OP_cond_testc     : "cond_testc",
+}
+
+func (self _Op) String() string {
+    if ret := _OpNames[self]; ret != "" {
+        return ret
+    } else {
+        return "<invalid>"
+    }
+}
+
+func _OP_int() _Op {
+    switch _INT_SIZE {
+        case 32: return _OP_i32
+        case 64: return _OP_i64
+        default: panic("unsupported int size")
+    }
+}
+
+func _OP_uint() _Op {
+    switch _INT_SIZE {
+        case 32: return _OP_u32
+        case 64: return _OP_u64
+        default: panic("unsupported uint size")
+    }
+}
+
+func _OP_uintptr() _Op {
+    switch _PTR_SIZE {
+        case 32: return _OP_u32
+        case 64: return _OP_u64
+        default: panic("unsupported pointer size")
+    }
+}
+
+func _OP_is_zero_ints() _Op {
+    switch _INT_SIZE {
+        case 32: return _OP_is_zero_4
+        case 64: return _OP_is_zero_8
+        default: panic("unsupported integer size")
+    }
+}
+
+type _Instr struct {
+    u uint64            // union {op: 8, _: 8, vi: 48}, vi maybe int or len(str)
+    p unsafe.Pointer    // maybe GoString.Ptr, or *GoType
+}
+
+func packOp(op _Op) uint64 {
+    return uint64(op) << 56
+}
+
+func newInsOp(op _Op) _Instr {
+    return _Instr{u: packOp(op)}
+}
+
+func newInsVi(op _Op, vi int) _Instr {
+    return _Instr{u: packOp(op) | rt.PackInt(vi)}
+}
+
+func newInsVs(op _Op, vs string) _Instr {
+    return _Instr {
+        u: packOp(op) | rt.PackInt(len(vs)),
+        p: (*rt.GoString)(unsafe.Pointer(&vs)).Ptr,
+    }
+}
+
+func newInsVt(op _Op, vt reflect.Type) _Instr {
+    return _Instr {
+        u: packOp(op),
+        p: unsafe.Pointer(rt.UnpackType(vt)),
+    }
+}
+
+func newInsVp(op _Op, vt reflect.Type, pv bool) _Instr {
+    i := 0
+    if pv {
+        i = 1
+    }
+    return _Instr {
+        u: packOp(op) | rt.PackInt(i),
+        p: unsafe.Pointer(rt.UnpackType(vt)),
+    }
+}
+
+func (self _Instr) op() _Op {
+    return _Op(self.u >> 56)
+}
+
+func (self _Instr) vi() int {
+    return rt.UnpackInt(self.u)
+}
+
+func (self _Instr) vf() uint8 {
+    return (*rt.GoType)(self.p).KindFlags
+}
+
+func (self _Instr) vs() (v string) {
+    (*rt.GoString)(unsafe.Pointer(&v)).Ptr = self.p
+    (*rt.GoString)(unsafe.Pointer(&v)).Len = self.vi()
+    return
+}
+
+func (self _Instr) vk() reflect.Kind {
+    return (*rt.GoType)(self.p).Kind()
+}
+
+func (self _Instr) vt() reflect.Type {
+    return (*rt.GoType)(self.p).Pack()
+}
+
+func (self _Instr) vp() (vt reflect.Type, pv bool) {
+    return (*rt.GoType)(self.p).Pack(), rt.UnpackInt(self.u) == 1
+}
+
+func (self _Instr) i64() int64 {
+    return int64(self.vi())
+}
+
+func (self _Instr) vlen() int {
+    return int((*rt.GoType)(self.p).Size)
+}
+
+func (self _Instr) isBranch() bool {
+    switch self.op() {
+        case _OP_goto          : fallthrough
+        case _OP_is_nil        : fallthrough
+        case _OP_is_nil_p1     : fallthrough
+        case _OP_is_zero_1     : fallthrough
+        case _OP_is_zero_2     : fallthrough
+        case _OP_is_zero_4     : fallthrough
+        case _OP_is_zero_8     : fallthrough
+        case _OP_map_check_key : fallthrough
+        case _OP_map_write_key : fallthrough
+        case _OP_slice_next    : fallthrough
+        case _OP_cond_testc    : return true
+        default                : return false
+    }
+}
+
+func (self _Instr) disassemble() string {
+    switch self.op() {
+        case _OP_byte           : return fmt.Sprintf("%-18s%s", self.op().String(), strconv.QuoteRune(rune(self.vi())))
+        case _OP_text           : return fmt.Sprintf("%-18s%s", self.op().String(), strconv.Quote(self.vs()))
+        case _OP_index          : return fmt.Sprintf("%-18s%d", self.op().String(), self.vi())
+        case _OP_recurse        : fallthrough
+        case _OP_map_iter       : fallthrough
+        case _OP_marshal        : fallthrough
+        case _OP_marshal_p      : fallthrough
+        case _OP_marshal_text   : fallthrough
+        case _OP_marshal_text_p : return fmt.Sprintf("%-18s%s", self.op().String(), self.vt())
+        case _OP_goto           : fallthrough
+        case _OP_is_nil         : fallthrough
+        case _OP_is_nil_p1      : fallthrough
+        case _OP_is_zero_1      : fallthrough
+        case _OP_is_zero_2      : fallthrough
+        case _OP_is_zero_4      : fallthrough
+        case _OP_is_zero_8      : fallthrough
+        case _OP_is_zero_map    : fallthrough
+        case _OP_cond_testc     : fallthrough
+        case _OP_map_check_key  : fallthrough
+        case _OP_map_write_key  : return fmt.Sprintf("%-18sL_%d", self.op().String(), self.vi())
+        case _OP_slice_next     : return fmt.Sprintf("%-18sL_%d, %s", self.op().String(), self.vi(), self.vt())
+        default                 : return self.op().String()
+    }
+}
+
+type (
+	_Program []_Instr
+)
+
+func (self _Program) pc() int {
+    return len(self)
+}
+
+func (self _Program) tag(n int) {
+    if n >= _MaxStack {
+        panic("type nesting too deep")
+    }
+}
+
+func (self _Program) pin(i int) {
+    v := &self[i]
+    v.u &= 0xffff000000000000
+    v.u |= rt.PackInt(self.pc())
+}
+
+func (self _Program) rel(v []int) {
+    for _, i := range v {
+        self.pin(i)
+    }
+}
+
+func (self *_Program) add(op _Op) {
+    *self = append(*self, newInsOp(op))
+}
+
+func (self *_Program) key(op _Op) {
+    *self = append(*self,
+        newInsVi(_OP_byte, '"'),
+        newInsOp(op),
+        newInsVi(_OP_byte, '"'),
+    )
+}
+
+func (self *_Program) int(op _Op, vi int) {
+    *self = append(*self, newInsVi(op, vi))
+}
+
+func (self *_Program) str(op _Op, vs string) {
+    *self = append(*self, newInsVs(op, vs))
+}
+
+func (self *_Program) rtt(op _Op, vt reflect.Type) {
+    *self = append(*self, newInsVt(op, vt))
+}
+
+func (self *_Program) vp(op _Op, vt reflect.Type, pv bool) {
+    *self = append(*self, newInsVp(op, vt, pv))
+}
+
+func (self _Program) disassemble() string {
+    nb  := len(self)
+    tab := make([]bool, nb + 1)
+    ret := make([]string, 0, nb + 1)
+
+    /* prescan to get all the labels */
+    for _, ins := range self {
+        if ins.isBranch() {
+            tab[ins.vi()] = true
+        }
+    }
+
+    /* disassemble each instruction */
+    for i, ins := range self {
+        if !tab[i] {
+            ret = append(ret, "\t" + ins.disassemble())
+        } else {
+            ret = append(ret, fmt.Sprintf("L_%d:\n\t%s", i, ins.disassemble()))
+        }
+    }
+
+    /* add the last label, if needed */
+    if tab[nb] {
+        ret = append(ret, fmt.Sprintf("L_%d:", nb))
+    }
+
+    /* add an "end" indicator, and join all the strings */
+    return strings.Join(append(ret, "\tend"), "\n")
+}
+
+type _Compiler struct {
+    opts option.CompileOptions
+    pv   bool
+    tab  map[reflect.Type]bool
+    rec  map[reflect.Type]uint8
+}
+
+func newCompiler() *_Compiler {
+    return &_Compiler {
+        opts: option.DefaultCompileOptions(),
+        tab: map[reflect.Type]bool{},
+        rec: map[reflect.Type]uint8{},
+    }
+}
+
+func (self *_Compiler) apply(opts option.CompileOptions) *_Compiler {
+    self.opts = opts
+    if self.opts.RecursiveDepth > 0 {
+        self.rec = map[reflect.Type]uint8{}
+    }
+    return self
+}
+
+func (self *_Compiler) rescue(ep *error) {
+    if val := recover(); val != nil {
+        if err, ok := val.(error); ok {
+            *ep = err
+        } else {
+            panic(val)
+        }
+    }
+}
+
+func (self *_Compiler) compile(vt reflect.Type, pv bool) (ret _Program, err error) {
+    defer self.rescue(&err)
+    self.compileOne(&ret, 0, vt, pv)
+    return
+}
+
+func (self *_Compiler) compileOne(p *_Program, sp int, vt reflect.Type, pv bool) {
+    if self.tab[vt] {
+        p.vp(_OP_recurse, vt, pv)
+    } else {
+        self.compileRec(p, sp, vt, pv)
+    }
+}
+
+func (self *_Compiler) compileRec(p *_Program, sp int, vt reflect.Type, pv bool) {
+    pr := self.pv
+    pt := reflect.PtrTo(vt)
+
+    /* check for addressable `json.Marshaler` with pointer receiver */
+    if pv && pt.Implements(jsonMarshalerType) {
+        p.rtt(_OP_marshal_p, pt)
+        return
+    }
+
+    /* check for `json.Marshaler` */
+    if vt.Implements(jsonMarshalerType) {
+        self.compileMarshaler(p, _OP_marshal, vt, jsonMarshalerType)
+        return
+    }
+
+    /* check for addressable `encoding.TextMarshaler` with pointer receiver */
+    if pv && pt.Implements(encodingTextMarshalerType) {
+        p.rtt(_OP_marshal_text_p, pt)
+        return
+    }
+
+    /* check for `encoding.TextMarshaler` */
+    if vt.Implements(encodingTextMarshalerType) {
+        self.compileMarshaler(p, _OP_marshal_text, vt, encodingTextMarshalerType)
+        return
+    }
+
+    /* enter the recursion, and compile the type */
+    self.pv = pv
+    self.tab[vt] = true
+    self.compileOps(p, sp, vt)
+
+    /* exit the recursion */
+    self.pv = pr
+    delete(self.tab, vt)
+}
+
+func (self *_Compiler) compileOps(p *_Program, sp int, vt reflect.Type) {
+    switch vt.Kind() {
+        case reflect.Bool      : p.add(_OP_bool)
+        case reflect.Int       : p.add(_OP_int())
+        case reflect.Int8      : p.add(_OP_i8)
+        case reflect.Int16     : p.add(_OP_i16)
+        case reflect.Int32     : p.add(_OP_i32)
+        case reflect.Int64     : p.add(_OP_i64)
+        case reflect.Uint      : p.add(_OP_uint())
+        case reflect.Uint8     : p.add(_OP_u8)
+        case reflect.Uint16    : p.add(_OP_u16)
+        case reflect.Uint32    : p.add(_OP_u32)
+        case reflect.Uint64    : p.add(_OP_u64)
+        case reflect.Uintptr   : p.add(_OP_uintptr())
+        case reflect.Float32   : p.add(_OP_f32)
+        case reflect.Float64   : p.add(_OP_f64)
+        case reflect.String    : self.compileString    (p, vt)
+        case reflect.Array     : self.compileArray     (p, sp, vt.Elem(), vt.Len())
+        case reflect.Interface : self.compileInterface (p, vt)
+        case reflect.Map       : self.compileMap       (p, sp, vt)
+        case reflect.Ptr       : self.compilePtr       (p, sp, vt.Elem())
+        case reflect.Slice     : self.compileSlice     (p, sp, vt.Elem())
+        case reflect.Struct    : self.compileStruct    (p, sp, vt)
+        default                : panic                 (error_type(vt))
+    }
+}
+
+func (self *_Compiler) compileNil(p *_Program, sp int, vt reflect.Type, nil_op _Op, fn func(*_Program, int, reflect.Type)) {
+    x := p.pc()
+    p.add(_OP_is_nil)
+    fn(p, sp, vt)
+    e := p.pc()
+    p.add(_OP_goto)
+    p.pin(x)
+    p.add(nil_op)
+    p.pin(e)
+}
+
+func (self *_Compiler) compilePtr(p *_Program, sp int, vt reflect.Type) {
+    self.compileNil(p, sp, vt, _OP_null, self.compilePtrBody)
+}
+
+func (self *_Compiler) compilePtrBody(p *_Program, sp int, vt reflect.Type) {
+    p.tag(sp)
+    p.add(_OP_save)
+    p.add(_OP_deref)
+    self.compileOne(p, sp + 1, vt, true)
+    p.add(_OP_drop)
+}
+
+func (self *_Compiler) compileMap(p *_Program, sp int, vt reflect.Type) {
+    self.compileNil(p, sp, vt, _OP_empty_obj, self.compileMapBody)
+}
+
+func (self *_Compiler) compileMapBody(p *_Program, sp int, vt reflect.Type) {
+    p.tag(sp + 1)
+    p.int(_OP_byte, '{')
+    p.add(_OP_save)
+    p.rtt(_OP_map_iter, vt)
+    p.add(_OP_save)
+    i := p.pc()
+    p.add(_OP_map_check_key)
+    u := p.pc()
+    p.add(_OP_map_write_key)
+    self.compileMapBodyKey(p, vt.Key())
+    p.pin(u)
+    p.int(_OP_byte, ':')
+    p.add(_OP_map_value_next)
+    self.compileOne(p, sp + 2, vt.Elem(), false)
+    j := p.pc()
+    p.add(_OP_map_check_key)
+    p.int(_OP_byte, ',')
+    v := p.pc()
+    p.add(_OP_map_write_key)
+    self.compileMapBodyKey(p, vt.Key())
+    p.pin(v)
+    p.int(_OP_byte, ':')
+    p.add(_OP_map_value_next)
+    self.compileOne(p, sp + 2, vt.Elem(), false)
+    p.int(_OP_goto, j)
+    p.pin(i)
+    p.pin(j)
+    p.add(_OP_map_stop)
+    p.add(_OP_drop_2)
+    p.int(_OP_byte, '}')
+}
+
+func (self *_Compiler) compileMapBodyKey(p *_Program, vk reflect.Type) {
+    if !vk.Implements(encodingTextMarshalerType) {
+        self.compileMapBodyTextKey(p, vk)
+    } else {
+        self.compileMapBodyUtextKey(p, vk)
+    }
+}
+
+func (self *_Compiler) compileMapBodyTextKey(p *_Program, vk reflect.Type) {
+    switch vk.Kind() {
+        case reflect.Invalid : panic("map key is nil")
+        case reflect.Bool    : p.key(_OP_bool)
+        case reflect.Int     : p.key(_OP_int())
+        case reflect.Int8    : p.key(_OP_i8)
+        case reflect.Int16   : p.key(_OP_i16)
+        case reflect.Int32   : p.key(_OP_i32)
+        case reflect.Int64   : p.key(_OP_i64)
+        case reflect.Uint    : p.key(_OP_uint())
+        case reflect.Uint8   : p.key(_OP_u8)
+        case reflect.Uint16  : p.key(_OP_u16)
+        case reflect.Uint32  : p.key(_OP_u32)
+        case reflect.Uint64  : p.key(_OP_u64)
+        case reflect.Uintptr : p.key(_OP_uintptr())
+        case reflect.Float32 : p.key(_OP_f32)
+        case reflect.Float64 : p.key(_OP_f64)
+        case reflect.String  : self.compileString(p, vk)
+        default              : panic(error_type(vk))
+    }
+}
+
+func (self *_Compiler) compileMapBodyUtextKey(p *_Program, vk reflect.Type) {
+    if vk.Kind() != reflect.Ptr {
+        p.rtt(_OP_marshal_text, vk)
+    } else {
+        self.compileMapBodyUtextPtr(p, vk)
+    }
+}
+
+func (self *_Compiler) compileMapBodyUtextPtr(p *_Program, vk reflect.Type) {
+    i := p.pc()
+    p.add(_OP_is_nil)
+    p.rtt(_OP_marshal_text, vk)
+    j := p.pc()
+    p.add(_OP_goto)
+    p.pin(i)
+    p.str(_OP_text, "\"\"")
+    p.pin(j)
+}
+
+func (self *_Compiler) compileSlice(p *_Program, sp int, vt reflect.Type) {
+    self.compileNil(p, sp, vt, _OP_empty_arr, self.compileSliceBody)
+}
+
+func (self *_Compiler) compileSliceBody(p *_Program, sp int, vt reflect.Type) {
+    if isSimpleByte(vt) {
+        p.add(_OP_bin)
+    } else {
+        self.compileSliceArray(p, sp, vt)
+    }
+}
+
+func (self *_Compiler) compileSliceArray(p *_Program, sp int, vt reflect.Type) {
+    p.tag(sp)
+    p.int(_OP_byte, '[')
+    p.add(_OP_save)
+    p.add(_OP_slice_len)
+    i := p.pc()
+    p.rtt(_OP_slice_next, vt)
+    self.compileOne(p, sp + 1, vt, true)
+    j := p.pc()
+    p.rtt(_OP_slice_next, vt)
+    p.int(_OP_byte, ',')
+    self.compileOne(p, sp + 1, vt, true)
+    p.int(_OP_goto, j)
+    p.pin(i)
+    p.pin(j)
+    p.add(_OP_drop)
+    p.int(_OP_byte, ']')
+}
+
+func (self *_Compiler) compileArray(p *_Program, sp int, vt reflect.Type, nb int) {
+    p.tag(sp)
+    p.int(_OP_byte, '[')
+    p.add(_OP_save)
+
+    /* first item */
+    if nb != 0 {
+        self.compileOne(p, sp + 1, vt, self.pv)
+        p.add(_OP_load)
+    }
+
+    /* remaining items */
+    for i := 1; i < nb; i++ {
+        p.int(_OP_byte, ',')
+        p.int(_OP_index, i * int(vt.Size()))
+        self.compileOne(p, sp + 1, vt, self.pv)
+        p.add(_OP_load)
+    }
+
+    /* end of array */
+    p.add(_OP_drop)
+    p.int(_OP_byte, ']')
+}
+
+func (self *_Compiler) compileString(p *_Program, vt reflect.Type) {
+    if vt != jsonNumberType {
+        p.add(_OP_str)
+    } else {
+        p.add(_OP_number)
+    }
+}
+
+func (self *_Compiler) compileStruct(p *_Program, sp int, vt reflect.Type) {
+    if sp >= self.opts.MaxInlineDepth || p.pc() >= _MAX_ILBUF || (sp > 0 && vt.NumField() >= _MAX_FIELDS) {
+        p.vp(_OP_recurse, vt, self.pv)
+        if self.opts.RecursiveDepth > 0 {
+            if self.pv {
+                self.rec[vt] = 1
+            } else {
+                self.rec[vt] = 0
+            }
+        }
+    } else {
+        self.compileStructBody(p, sp, vt)
+    }
+}
+
+func (self *_Compiler) compileStructBody(p *_Program, sp int, vt reflect.Type) {
+    p.tag(sp)
+    p.int(_OP_byte, '{')
+    p.add(_OP_save)
+    p.add(_OP_cond_set)
+
+    /* compile each field */
+    for _, fv := range resolver.ResolveStruct(vt) {
+        var s []int
+        var o resolver.Offset
+
+        /* "omitempty" for arrays */
+        if fv.Type.Kind() == reflect.Array {
+            if fv.Type.Len() == 0 && (fv.Opts & resolver.F_omitempty) != 0 {
+                continue
+            }
+        }
+
+        /* index to the field */
+        for _, o = range fv.Path {
+            if p.int(_OP_index, int(o.Size)); o.Kind == resolver.F_deref {
+                s = append(s, p.pc())
+                p.add(_OP_is_nil)
+                p.add(_OP_deref)
+            }
+        }
+
+        /* check for "omitempty" option */
+        if fv.Type.Kind() != reflect.Struct && fv.Type.Kind() != reflect.Array && (fv.Opts & resolver.F_omitempty) != 0 {
+            s = append(s, p.pc())
+            self.compileStructFieldZero(p, fv.Type)
+        }
+
+        /* add the comma if not the first element */
+        i := p.pc()
+        p.add(_OP_cond_testc)
+        p.int(_OP_byte, ',')
+        p.pin(i)
+
+        /* compile the key and value */
+        ft := fv.Type
+        p.str(_OP_text, Quote(fv.Name) + ":")
+
+        /* check for "stringnize" option */
+        if (fv.Opts & resolver.F_stringize) == 0 {
+            self.compileOne(p, sp + 1, ft, self.pv)
+        } else {
+            self.compileStructFieldStr(p, sp + 1, ft)
+        }
+
+        /* patch the skipping jumps and reload the struct pointer */
+        p.rel(s)
+        p.add(_OP_load)
+    }
+
+    /* end of object */
+    p.add(_OP_drop)
+    p.int(_OP_byte, '}')
+}
+
+func (self *_Compiler) compileStructFieldStr(p *_Program, sp int, vt reflect.Type) {
+    pc := -1
+    ft := vt
+    sv := false
+
+    /* dereference the pointer if needed */
+    if ft.Kind() == reflect.Ptr {
+        ft = ft.Elem()
+    }
+
+    /* check if it can be stringized */
+    switch ft.Kind() {
+        case reflect.Bool    : sv = true
+        case reflect.Int     : sv = true
+        case reflect.Int8    : sv = true
+        case reflect.Int16   : sv = true
+        case reflect.Int32   : sv = true
+        case reflect.Int64   : sv = true
+        case reflect.Uint    : sv = true
+        case reflect.Uint8   : sv = true
+        case reflect.Uint16  : sv = true
+        case reflect.Uint32  : sv = true
+        case reflect.Uint64  : sv = true
+        case reflect.Uintptr : sv = true
+        case reflect.Float32 : sv = true
+        case reflect.Float64 : sv = true
+        case reflect.String  : sv = true
+    }
+
+    /* if it's not, ignore the "string" and follow the regular path */
+    if !sv {
+        self.compileOne(p, sp, vt, self.pv)
+        return
+    }
+
+    /* dereference the pointer */
+    if vt.Kind() == reflect.Ptr {
+        pc = p.pc()
+        vt = vt.Elem()
+        p.add(_OP_is_nil)
+        p.add(_OP_deref)
+    }
+
+    /* special case of a double-quoted string */
+    if ft != jsonNumberType && ft.Kind() == reflect.String {
+        p.add(_OP_quote)
+    } else {
+        self.compileStructFieldQuoted(p, sp, vt)
+    }
+
+    /* the "null" case of the pointer */
+    if pc != -1 {
+        e := p.pc()
+        p.add(_OP_goto)
+        p.pin(pc)
+        p.add(_OP_null)
+        p.pin(e)
+    }
+}
+
+func (self *_Compiler) compileStructFieldZero(p *_Program, vt reflect.Type) {
+    switch vt.Kind() {
+        case reflect.Bool      : p.add(_OP_is_zero_1)
+        case reflect.Int       : p.add(_OP_is_zero_ints())
+        case reflect.Int8      : p.add(_OP_is_zero_1)
+        case reflect.Int16     : p.add(_OP_is_zero_2)
+        case reflect.Int32     : p.add(_OP_is_zero_4)
+        case reflect.Int64     : p.add(_OP_is_zero_8)
+        case reflect.Uint      : p.add(_OP_is_zero_ints())
+        case reflect.Uint8     : p.add(_OP_is_zero_1)
+        case reflect.Uint16    : p.add(_OP_is_zero_2)
+        case reflect.Uint32    : p.add(_OP_is_zero_4)
+        case reflect.Uint64    : p.add(_OP_is_zero_8)
+        case reflect.Uintptr   : p.add(_OP_is_nil)
+        case reflect.Float32   : p.add(_OP_is_zero_4)
+        case reflect.Float64   : p.add(_OP_is_zero_8)
+        case reflect.String    : p.add(_OP_is_nil_p1)
+        case reflect.Interface : p.add(_OP_is_nil)
+        case reflect.Map       : p.add(_OP_is_zero_map)
+        case reflect.Ptr       : p.add(_OP_is_nil)
+        case reflect.Slice     : p.add(_OP_is_nil_p1)
+        default                : panic(error_type(vt))
+    }
+}
+
+func (self *_Compiler) compileStructFieldQuoted(p *_Program, sp int, vt reflect.Type) {
+    p.int(_OP_byte, '"')
+    self.compileOne(p, sp, vt, self.pv)
+    p.int(_OP_byte, '"')
+}
+
+func (self *_Compiler) compileInterface(p *_Program, vt reflect.Type) {
+    x := p.pc()
+    p.add(_OP_is_nil_p1)
+
+    /* iface and efaces are different */
+    if vt.NumMethod() == 0 {
+        p.add(_OP_eface)
+    } else {
+        p.add(_OP_iface)
+    }
+
+    /* the "null" value */
+    e := p.pc()
+    p.add(_OP_goto)
+    p.pin(x)
+    p.add(_OP_null)
+    p.pin(e)
+}
+
+func (self *_Compiler) compileMarshaler(p *_Program, op _Op, vt reflect.Type, mt reflect.Type) {
+    pc := p.pc()
+    vk := vt.Kind()
+
+    /* direct receiver */
+    if vk != reflect.Ptr {
+        p.rtt(op, vt)
+        return
+    }
+
+    /* value receiver with a pointer type, check for nil before calling the marshaler */
+    p.add(_OP_is_nil)
+    p.rtt(op, vt)
+    i := p.pc()
+    p.add(_OP_goto)
+    p.pin(pc)
+    p.add(_OP_null)
+    p.pin(i)
+}

vendor/github.com/bytedance/sonic/internal/encoder/debug_go116.go

@@ -0,0 +1,66 @@
+// +build go1.16,!go1.17
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `os`
+    `strings`
+    `runtime`
+    `runtime/debug`
+
+    `github.com/bytedance/sonic/internal/jit`
+)
+
+var (
+    debugSyncGC  = os.Getenv("SONIC_SYNC_GC") != ""
+    debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == ""
+)
+
+var (
+    _Instr_End _Instr = newInsOp(_OP_null)
+
+    _F_gc       = jit.Func(runtime.GC)
+    _F_force_gc = jit.Func(debug.FreeOSMemory)
+    _F_println  = jit.Func(println_wrapper)
+)
+
+func println_wrapper(i int, op1 int, op2 int){
+    println(i, " Intrs ", op1, _OpNames[op1], "next: ", op2, _OpNames[op2])
+}
+
+func (self *_Assembler) force_gc() {
+    self.call_go(_F_gc)
+    self.call_go(_F_force_gc)
+}
+
+func (self *_Assembler) debug_instr(i int, v *_Instr) {
+    if debugSyncGC {
+        if (i+1 == len(self.p)) {
+            self.print_gc(i, v, &_Instr_End) 
+        } else {
+            next := &(self.p[i+1])
+            self.print_gc(i, v, next)
+            name := _OpNames[next.op()]
+            if strings.Contains(name, "save") {
+                return
+            }
+        }
+        self.force_gc()
+    }
+}

vendor/github.com/bytedance/sonic/internal/encoder/debug_go117.go

@@ -0,0 +1,205 @@
+// +build go1.17,!go1.23
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `fmt`
+    `os`
+    `runtime`
+    `strings`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/twitchyliquid64/golang-asm/obj`
+)
+
+const _FP_debug = 128
+
+var (
+    debugSyncGC  = os.Getenv("SONIC_SYNC_GC") != ""
+    debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == ""
+    debugCheckPtr = os.Getenv("SONIC_CHECK_POINTER") != ""
+)
+
+var (
+    _Instr_End = newInsOp(_OP_is_nil)
+
+    _F_gc       = jit.Func(gc)
+    _F_println  = jit.Func(println_wrapper)
+    _F_print    = jit.Func(print)
+)
+
+func (self *_Assembler) dsave(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _FP_debug / 8 - 1 {
+            panic("too many registers to save")
+        } else {
+            self.Emit("MOVQ", v, jit.Ptr(_SP, _FP_fargs + _FP_saves + _FP_locals + int64(i) * 8))
+        }
+    }
+}
+
+func (self *_Assembler) dload(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _FP_debug / 8 - 1 {
+            panic("too many registers to load")
+        } else {
+            self.Emit("MOVQ", jit.Ptr(_SP, _FP_fargs + _FP_saves + _FP_locals + int64(i) * 8), v)
+        }
+    }
+}
+
+func println_wrapper(i int, op1 int, op2 int){
+    println(i, " Intrs ", op1, _OpNames[op1], "next: ", op2, _OpNames[op2])
+}
+
+func print(i int){
+    println(i)
+}
+
+func gc() {
+    if !debugSyncGC {
+        return
+    }
+    runtime.GC()
+    // debug.FreeOSMemory()
+}
+
+func (self *_Assembler) dcall(fn obj.Addr) {
+    self.Emit("MOVQ", fn, _R10)  // MOVQ ${fn}, R10
+    self.Rjmp("CALL", _R10)       // CALL R10
+}
+
+func (self *_Assembler) debug_gc() {
+    if !debugSyncGC {
+        return
+    }
+    self.dsave(_REG_debug...)
+    self.dcall(_F_gc)
+    self.dload(_REG_debug...)
+}
+
+func (self *_Assembler) debug_instr(i int, v *_Instr) {
+    if debugSyncGC {
+        if i+1 == len(self.p) {
+            self.print_gc(i, v, &_Instr_End)
+        } else {
+            next := &(self.p[i+1])
+            self.print_gc(i, v, next)
+            name := _OpNames[next.op()]
+            if strings.Contains(name, "save") {
+                return
+            }
+        }
+        // self.debug_gc()
+    }
+}
+
+//go:noescape
+//go:linkname checkptrBase runtime.checkptrBase
+func checkptrBase(p unsafe.Pointer) uintptr
+
+//go:noescape
+//go:linkname findObject runtime.findObject
+func findObject(p, refBase, refOff uintptr) (base uintptr, s unsafe.Pointer, objIndex uintptr)
+
+var (
+    _F_checkptr = jit.Func(checkptr)
+    _F_printptr = jit.Func(printptr)
+)
+
+var (
+    _R10 = jit.Reg("R10")
+)
+var _REG_debug = []obj.Addr {
+    jit.Reg("AX"),
+    jit.Reg("BX"),
+    jit.Reg("CX"),
+    jit.Reg("DX"),
+    jit.Reg("DI"),
+    jit.Reg("SI"),
+    jit.Reg("BP"),
+    jit.Reg("SP"),
+    jit.Reg("R8"),
+    jit.Reg("R9"),
+    jit.Reg("R10"),
+    jit.Reg("R11"),
+    jit.Reg("R12"),
+    jit.Reg("R13"),
+    jit.Reg("R14"),
+    jit.Reg("R15"),
+}
+
+func checkptr(ptr uintptr) {
+    if ptr == 0 {
+        return
+    }
+    fmt.Printf("pointer: %x\n", ptr)
+    f := checkptrBase(unsafe.Pointer(uintptr(ptr)))
+    if f == 0 {
+        fmt.Printf("! unknown-based pointer: %x\n", ptr)
+    } else if f == 1 {
+        fmt.Printf("! stack pointer: %x\n", ptr)
+    } else {
+        fmt.Printf("base: %x\n", f)
+    }
+    findobj(ptr)
+}
+
+func findobj(ptr uintptr) {
+    base, s, objIndex := findObject(ptr, 0, 0)
+    if s != nil && base == 0 {
+        fmt.Printf("! invalid pointer: %x\n", ptr)
+    }
+    fmt.Printf("objIndex: %d\n", objIndex)
+}
+
+func (self *_Assembler) check_ptr(ptr obj.Addr, lea bool) {
+    if !debugCheckPtr {
+        return
+    }
+
+    self.dsave(_REG_debug...)
+    if lea {
+        self.Emit("LEAQ", ptr, _R10)
+    } else {
+        self.Emit("MOVQ", ptr, _R10)
+    }
+    self.Emit("MOVQ", _R10, jit.Ptr(_SP, 0))
+    self.dcall(_F_checkptr)
+    self.dload(_REG_debug...)
+}
+
+func printptr(i int, ptr uintptr) {
+    fmt.Printf("[%d] ptr: %x\n", i, ptr)
+}
+
+func (self *_Assembler) print_ptr(i int, ptr obj.Addr, lea bool) {
+    self.dsave(_REG_debug...)
+    if lea {
+        self.Emit("LEAQ", ptr, _R10)
+    } else {
+        self.Emit("MOVQ", ptr, _R10)
+    }
+
+    self.Emit("MOVQ", jit.Imm(int64(i)), _AX)
+    self.Emit("MOVQ", _R10, _BX)
+    self.dcall(_F_printptr)
+    self.dload(_REG_debug...)
+}

vendor/github.com/bytedance/sonic/internal/encoder/encoder.go

@@ -0,0 +1,355 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `bytes`
+    `encoding/json`
+    `reflect`
+    `runtime`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/utf8`
+    `github.com/bytedance/sonic/option`
+)
+
+// Options is a set of encoding options.
+type Options uint64
+
+const (
+    bitSortMapKeys          = iota
+    bitEscapeHTML          
+    bitCompactMarshaler
+    bitNoQuoteTextMarshaler
+    bitNoNullSliceOrMap
+    bitValidateString
+    bitNoValidateJSONMarshaler
+    bitNoEncoderNewline 
+
+    // used for recursive compile
+    bitPointerValue = 63
+)
+
+const (
+    // SortMapKeys indicates that the keys of a map needs to be sorted 
+    // before serializing into JSON.
+    // WARNING: This hurts performance A LOT, USE WITH CARE.
+    SortMapKeys          Options = 1 << bitSortMapKeys
+
+    // EscapeHTML indicates encoder to escape all HTML characters 
+    // after serializing into JSON (see https://pkg.go.dev/encoding/json#HTMLEscape).
+    // WARNING: This hurts performance A LOT, USE WITH CARE.
+    EscapeHTML           Options = 1 << bitEscapeHTML
+
+    // CompactMarshaler indicates that the output JSON from json.Marshaler 
+    // is always compact and needs no validation 
+    CompactMarshaler     Options = 1 << bitCompactMarshaler
+
+    // NoQuoteTextMarshaler indicates that the output text from encoding.TextMarshaler 
+    // is always escaped string and needs no quoting
+    NoQuoteTextMarshaler Options = 1 << bitNoQuoteTextMarshaler
+
+    // NoNullSliceOrMap indicates all empty Array or Object are encoded as '[]' or '{}',
+    // instead of 'null'
+    NoNullSliceOrMap     Options = 1 << bitNoNullSliceOrMap
+
+    // ValidateString indicates that encoder should validate the input string
+    // before encoding it into JSON.
+    ValidateString       Options = 1 << bitValidateString
+
+    // NoValidateJSONMarshaler indicates that the encoder should not validate the output string
+    // after encoding the JSONMarshaler to JSON.
+    NoValidateJSONMarshaler Options = 1 << bitNoValidateJSONMarshaler
+
+    // NoEncoderNewline indicates that the encoder should not add a newline after every message
+    NoEncoderNewline Options = 1 << bitNoEncoderNewline
+  
+    // CompatibleWithStd is used to be compatible with std encoder.
+    CompatibleWithStd Options = SortMapKeys | EscapeHTML | CompactMarshaler
+)
+
+// Encoder represents a specific set of encoder configurations.
+type Encoder struct {
+    Opts Options
+    prefix string
+    indent string
+}
+
+// Encode returns the JSON encoding of v.
+func (self *Encoder) Encode(v interface{}) ([]byte, error) {
+    if self.indent != "" || self.prefix != "" { 
+        return EncodeIndented(v, self.prefix, self.indent, self.Opts)
+    }
+    return Encode(v, self.Opts)
+}
+
+// SortKeys enables the SortMapKeys option.
+func (self *Encoder) SortKeys() *Encoder {
+    self.Opts |= SortMapKeys
+    return self
+}
+
+// SetEscapeHTML specifies if option EscapeHTML opens
+func (self *Encoder) SetEscapeHTML(f bool) {
+    if f {
+        self.Opts |= EscapeHTML
+    } else {
+        self.Opts &= ^EscapeHTML
+    }
+}
+
+// SetValidateString specifies if option ValidateString opens
+func (self *Encoder) SetValidateString(f bool) {
+    if f {
+        self.Opts |= ValidateString
+    } else {
+        self.Opts &= ^ValidateString
+    }
+}
+
+// SetNoValidateJSONMarshaler specifies if option NoValidateJSONMarshaler opens
+func (self *Encoder) SetNoValidateJSONMarshaler(f bool) {
+    if f {
+        self.Opts |= NoValidateJSONMarshaler
+    } else {
+        self.Opts &= ^NoValidateJSONMarshaler
+    }
+}
+
+// SetNoEncoderNewline specifies if option NoEncoderNewline opens
+func (self *Encoder) SetNoEncoderNewline(f bool) {
+    if f {
+        self.Opts |= NoEncoderNewline
+    } else {
+        self.Opts &= ^NoEncoderNewline
+    }
+}
+
+
+// SetCompactMarshaler specifies if option CompactMarshaler opens
+func (self *Encoder) SetCompactMarshaler(f bool) {
+    if f {
+        self.Opts |= CompactMarshaler
+    } else {
+        self.Opts &= ^CompactMarshaler
+    }
+}
+
+// SetNoQuoteTextMarshaler specifies if option NoQuoteTextMarshaler opens
+func (self *Encoder) SetNoQuoteTextMarshaler(f bool) {
+    if f {
+        self.Opts |= NoQuoteTextMarshaler
+    } else {
+        self.Opts &= ^NoQuoteTextMarshaler
+    }
+}
+
+// SetIndent instructs the encoder to format each subsequent encoded
+// value as if indented by the package-level function EncodeIndent().
+// Calling SetIndent("", "") disables indentation.
+func (enc *Encoder) SetIndent(prefix, indent string) {
+    enc.prefix = prefix
+    enc.indent = indent
+}
+
+// Quote returns the JSON-quoted version of s.
+func Quote(s string) string {
+    var n int
+    var p []byte
+
+    /* check for empty string */
+    if s == "" {
+        return `""`
+    }
+
+    /* allocate space for result */
+    n = len(s) + 2
+    p = make([]byte, 0, n)
+
+    /* call the encoder */
+    _ = encodeString(&p, s)
+    return rt.Mem2Str(p)
+}
+
+// Encode returns the JSON encoding of val, encoded with opts.
+func Encode(val interface{}, opts Options) ([]byte, error) {
+    var ret []byte
+
+    buf := newBytes()
+    err := encodeInto(&buf, val, opts)
+
+    /* check for errors */
+    if err != nil {
+        freeBytes(buf)
+        return nil, err
+    }
+
+    /* htmlescape or correct UTF-8 if opts enable */
+    old := buf
+    buf = encodeFinish(old, opts)
+    pbuf := ((*rt.GoSlice)(unsafe.Pointer(&buf))).Ptr
+    pold := ((*rt.GoSlice)(unsafe.Pointer(&old))).Ptr
+
+    /* return when allocated a new buffer */
+    if pbuf != pold {
+        freeBytes(old)
+        return buf, nil
+    }
+
+    /* make a copy of the result */
+    ret = make([]byte, len(buf))
+    copy(ret, buf)
+
+    freeBytes(buf)
+    /* return the buffer into pool */
+    return ret, nil
+}
+
+// EncodeInto is like Encode but uses a user-supplied buffer instead of allocating
+// a new one.
+func EncodeInto(buf *[]byte, val interface{}, opts Options) error {
+    err := encodeInto(buf, val, opts)
+    if err != nil {
+        return err
+    }
+    *buf = encodeFinish(*buf, opts)
+    return err
+}
+
+func encodeInto(buf *[]byte, val interface{}, opts Options) error {
+    stk := newStack()
+    efv := rt.UnpackEface(val)
+    err := encodeTypedPointer(buf, efv.Type, &efv.Value, stk, uint64(opts))
+
+    /* return the stack into pool */
+    if err != nil {
+        resetStack(stk)
+    }
+    freeStack(stk)
+
+    /* avoid GC ahead */
+    runtime.KeepAlive(buf)
+    runtime.KeepAlive(efv)
+    return err
+}
+
+func encodeFinish(buf []byte, opts Options) []byte {
+    if opts & EscapeHTML != 0 {
+        buf = HTMLEscape(nil, buf)
+    }
+    if opts & ValidateString != 0 && !utf8.Validate(buf) {
+        buf = utf8.CorrectWith(nil, buf, `\ufffd`)
+    }
+    return buf
+}
+
+var typeByte = rt.UnpackType(reflect.TypeOf(byte(0)))
+
+// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029
+// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029
+// so that the JSON will be safe to embed inside HTML <script> tags.
+// For historical reasons, web browsers don't honor standard HTML
+// escaping within <script> tags, so an alternative JSON encoding must
+// be used.
+func HTMLEscape(dst []byte, src []byte) []byte {
+    return htmlEscape(dst, src)
+}
+
+// EncodeIndented is like Encode but applies Indent to format the output.
+// Each JSON element in the output will begin on a new line beginning with prefix
+// followed by one or more copies of indent according to the indentation nesting.
+func EncodeIndented(val interface{}, prefix string, indent string, opts Options) ([]byte, error) {
+    var err error
+    var out []byte
+    var buf *bytes.Buffer
+
+    /* encode into the buffer */
+    out = newBytes()
+    err = EncodeInto(&out, val, opts)
+
+    /* check for errors */
+    if err != nil {
+        freeBytes(out)
+        return nil, err
+    }
+
+    /* indent the JSON */
+    buf = newBuffer()
+    err = json.Indent(buf, out, prefix, indent)
+
+    /* check for errors */
+    if err != nil {
+        freeBytes(out)
+        freeBuffer(buf)
+        return nil, err
+    }
+
+    /* copy to the result buffer */
+    ret := make([]byte, buf.Len())
+    copy(ret, buf.Bytes())
+
+    /* return the buffers into pool */
+    freeBytes(out)
+    freeBuffer(buf)
+    return ret, nil
+}
+
+// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
+// order to reduce the first-hit latency.
+//
+// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is
+// a compile option to set the depth of recursive compile for the nested struct type.
+func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
+    cfg := option.DefaultCompileOptions()
+    for _, opt := range opts {
+        opt(&cfg)
+    }
+    return pretouchRec(map[reflect.Type]uint8{vt: 0}, cfg)
+}
+
+// Valid validates json and returns first non-blank character position,
+// if it is only one valid json value.
+// Otherwise returns invalid character position using start.
+//
+// Note: it does not check for the invalid UTF-8 characters.
+func Valid(data []byte) (ok bool, start int) {
+    n := len(data)
+    if n == 0 {
+        return false, -1
+    }
+    s := rt.Mem2Str(data)
+    p := 0
+    m := types.NewStateMachine()
+    ret := native.ValidateOne(&s, &p, m, types.F_VALIDATE_STRING)
+    types.FreeStateMachine(m)
+
+    if ret < 0 {
+        return false, p-1
+    }
+
+    /* check for trailing spaces */
+    for ;p < n; p++ {
+        if (types.SPACE_MASK & (1 << data[p])) == 0 {
+            return false, p
+        }
+    }
+
+    return true, ret
+}

vendor/github.com/bytedance/sonic/internal/encoder/errors.go

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding/json`
+    `fmt`
+    `reflect`
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var _ERR_too_deep = &json.UnsupportedValueError {
+    Str   : "Value nesting too deep",
+    Value : reflect.ValueOf("..."),
+}
+
+var _ERR_nan_or_infinite = &json.UnsupportedValueError {
+    Str   : "NaN or ±Infinite",
+    Value : reflect.ValueOf("NaN or ±Infinite"),
+}
+
+func error_type(vtype reflect.Type) error {
+    return &json.UnsupportedTypeError{Type: vtype}
+}
+
+func error_number(number json.Number) error {
+    return &json.UnsupportedValueError {
+        Str   : "invalid number literal: " + strconv.Quote(string(number)),
+        Value : reflect.ValueOf(number),
+    }
+}
+
+func error_marshaler(ret []byte, pos int) error {
+    return fmt.Errorf("invalid Marshaler output json syntax at %d: %q", pos, ret)
+}
+
+const (
+    panicNilPointerOfNonEmptyString int = 1 + iota
+)
+
+func goPanic(code int, val unsafe.Pointer) {
+    switch(code){
+    case panicNilPointerOfNonEmptyString:
+        panic(fmt.Sprintf("val: %#v has nil pointer while its length is not zero!", (*rt.GoString)(val)))
+    default:
+        panic("encoder error!")
+    }
+}

vendor/github.com/bytedance/sonic/internal/encoder/mapiter.go

@@ -0,0 +1,199 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+	"encoding"
+	"reflect"
+	"sync"
+	"unsafe"
+
+	"github.com/bytedance/sonic/internal/native"
+	"github.com/bytedance/sonic/internal/rt"
+)
+
+type _MapPair struct {
+    k string  // when the map key is integer, k is pointed to m
+    v unsafe.Pointer
+    m [32]byte
+}
+
+type _MapIterator struct {
+    it rt.GoMapIterator     // must be the first field
+    kv rt.GoSlice           // slice of _MapPair
+    ki int
+}
+
+var (
+    iteratorPool = sync.Pool{}
+    iteratorPair = rt.UnpackType(reflect.TypeOf(_MapPair{}))
+)
+
+func init() {
+    if unsafe.Offsetof(_MapIterator{}.it) != 0 {
+        panic("_MapIterator.it is not the first field")
+    }
+}
+
+
+func newIterator() *_MapIterator {
+    if v := iteratorPool.Get(); v == nil {
+        return new(_MapIterator)
+    } else {
+        return resetIterator(v.(*_MapIterator))
+    }
+}
+
+func resetIterator(p *_MapIterator) *_MapIterator {
+    p.ki = 0
+    p.it = rt.GoMapIterator{}
+    p.kv.Len = 0
+    return p
+}
+
+func (self *_MapIterator) at(i int) *_MapPair {
+    return (*_MapPair)(unsafe.Pointer(uintptr(self.kv.Ptr) + uintptr(i) * unsafe.Sizeof(_MapPair{})))
+}
+
+func (self *_MapIterator) add() (p *_MapPair) {
+    p = self.at(self.kv.Len)
+    self.kv.Len++
+    return
+}
+
+func (self *_MapIterator) data() (p []_MapPair) {
+    *(*rt.GoSlice)(unsafe.Pointer(&p)) = self.kv
+    return
+}
+
+func (self *_MapIterator) append(t *rt.GoType, k unsafe.Pointer, v unsafe.Pointer) (err error) {
+    p := self.add()
+    p.v = v
+
+    /* check for strings */
+    if tk := t.Kind(); tk != reflect.String {
+        return self.appendGeneric(p, t, tk, k)
+    }
+
+    /* fast path for strings */
+    p.k = *(*string)(k)
+    return nil
+}
+
+func (self *_MapIterator) appendGeneric(p *_MapPair, t *rt.GoType, v reflect.Kind, k unsafe.Pointer) error {
+    switch v {
+        case reflect.Int       : p.k = rt.Mem2Str(p.m[:native.I64toa(&p.m[0], int64(*(*int)(k)))])      ; return nil
+        case reflect.Int8      : p.k = rt.Mem2Str(p.m[:native.I64toa(&p.m[0], int64(*(*int8)(k)))])     ; return nil
+        case reflect.Int16     : p.k = rt.Mem2Str(p.m[:native.I64toa(&p.m[0], int64(*(*int16)(k)))])    ; return nil
+        case reflect.Int32     : p.k = rt.Mem2Str(p.m[:native.I64toa(&p.m[0], int64(*(*int32)(k)))])    ; return nil
+        case reflect.Int64     : p.k = rt.Mem2Str(p.m[:native.I64toa(&p.m[0], *(*int64)(k))])           ; return nil
+        case reflect.Uint      : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], uint64(*(*uint)(k)))])    ; return nil
+        case reflect.Uint8     : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], uint64(*(*uint8)(k)))])   ; return nil
+        case reflect.Uint16    : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], uint64(*(*uint16)(k)))])  ; return nil
+        case reflect.Uint32    : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], uint64(*(*uint32)(k)))])  ; return nil
+        case reflect.Uint64    : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], *(*uint64)(k))])          ; return nil
+        case reflect.Uintptr   : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], uint64(*(*uintptr)(k)))]) ; return nil
+        case reflect.Interface : return self.appendInterface(p, t, k)
+        case reflect.Struct, reflect.Ptr : return self.appendConcrete(p, t, k)
+        default                : panic("unexpected map key type")
+    }
+}
+
+func (self *_MapIterator) appendConcrete(p *_MapPair, t *rt.GoType, k unsafe.Pointer) (err error) {
+    // compiler has already checked that the type implements the encoding.MarshalText interface
+    if !t.Indirect() {
+        k = *(*unsafe.Pointer)(k)
+    }
+    eface := rt.GoEface{Value: k, Type: t}.Pack()
+    out, err := eface.(encoding.TextMarshaler).MarshalText()
+    if err != nil {
+        return err
+    }
+    p.k = rt.Mem2Str(out)
+    return
+}
+
+func (self *_MapIterator) appendInterface(p *_MapPair, t *rt.GoType, k unsafe.Pointer) (err error) {
+    if len(rt.IfaceType(t).Methods) == 0 {
+        panic("unexpected map key type")
+    } else if p.k, err = asText(k); err == nil {
+        return nil
+    } else {
+        return
+    }
+}
+
+func iteratorStop(p *_MapIterator) {
+    iteratorPool.Put(p)
+}
+
+func iteratorNext(p *_MapIterator) {
+    i := p.ki
+    t := &p.it
+
+    /* check for unordered iteration */
+    if i < 0 {
+        mapiternext(t)
+        return
+    }
+
+    /* check for end of iteration */
+    if p.ki >= p.kv.Len {
+        t.K = nil
+        t.V = nil
+        return
+    }
+
+    /* update the key-value pair, and increase the pointer */
+    t.K = unsafe.Pointer(&p.at(p.ki).k)
+    t.V = p.at(p.ki).v
+    p.ki++
+}
+
+func iteratorStart(t *rt.GoMapType, m *rt.GoMap, fv uint64) (*_MapIterator, error) {
+    it := newIterator()
+    mapiterinit(t, m, &it.it)
+
+    /* check for key-sorting, empty map don't need sorting */
+    if m.Count == 0 || (fv & uint64(SortMapKeys)) == 0 {
+        it.ki = -1
+        return it, nil
+    }
+
+    /* pre-allocate space if needed */
+    if m.Count > it.kv.Cap {
+        it.kv = growslice(iteratorPair, it.kv, m.Count)
+    }
+
+    /* dump all the key-value pairs */
+    for ; it.it.K != nil; mapiternext(&it.it) {
+        if err := it.append(t.Key, it.it.K, it.it.V); err != nil {
+            iteratorStop(it)
+            return nil, err
+        }
+    }
+
+    /* sort the keys, map with only 1 item don't need sorting */
+    if it.ki = 1; m.Count > 1 {
+        radixQsort(it.data(), 0, maxDepth(it.kv.Len))
+    }
+
+    /* load the first pair into iterator */
+    it.it.V = it.at(0).v
+    it.it.K = unsafe.Pointer(&it.at(0).k)
+    return it, nil
+}

vendor/github.com/bytedance/sonic/internal/encoder/pools.go

@@ -0,0 +1,193 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `bytes`
+    `sync`
+    `unsafe`
+    `errors`
+    `reflect`
+
+    `github.com/bytedance/sonic/internal/caching`
+    `github.com/bytedance/sonic/option`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const (
+    _MaxStack  = 4096      // 4k states
+
+    _StackSize = unsafe.Sizeof(_Stack{})
+)
+
+var (
+    bytesPool    = sync.Pool{}
+    stackPool    = sync.Pool{}
+    bufferPool   = sync.Pool{}
+    programCache = caching.CreateProgramCache()
+)
+
+type _State struct {
+    x int
+    f uint64
+    p unsafe.Pointer
+    q unsafe.Pointer
+}
+
+type _Stack struct {
+    sp uint64
+    sb [_MaxStack]_State
+}
+
+type _Encoder func(
+    rb *[]byte,
+    vp unsafe.Pointer,
+    sb *_Stack,
+    fv uint64,
+) error
+
+var _KeepAlive struct {
+    rb *[]byte
+    vp unsafe.Pointer
+    sb *_Stack
+    fv uint64
+    err error
+    frame [_FP_offs]byte
+}
+
+var errCallShadow = errors.New("DON'T CALL THIS!")
+
+// Faker func of _Encoder, used to export its stackmap as _Encoder's
+func _Encoder_Shadow(rb *[]byte, vp unsafe.Pointer, sb *_Stack, fv uint64) (err error) {
+    // align to assembler_amd64.go: _FP_offs
+    var frame [_FP_offs]byte
+
+    // must keep all args and frames noticeable to GC
+    _KeepAlive.rb = rb
+    _KeepAlive.vp = vp
+    _KeepAlive.sb = sb
+    _KeepAlive.fv = fv
+    _KeepAlive.err = err
+    _KeepAlive.frame = frame
+
+    return errCallShadow
+}
+
+func newBytes() []byte {
+    if ret := bytesPool.Get(); ret != nil {
+        return ret.([]byte)
+    } else {
+        return make([]byte, 0, option.DefaultEncoderBufferSize)
+    }
+}
+
+func newStack() *_Stack {
+    if ret := stackPool.Get(); ret == nil {
+        return new(_Stack)
+    } else {
+        return ret.(*_Stack)
+    }
+}
+
+func resetStack(p *_Stack) {
+    memclrNoHeapPointers(unsafe.Pointer(p), _StackSize)
+}
+
+func newBuffer() *bytes.Buffer {
+    if ret := bufferPool.Get(); ret != nil {
+        return ret.(*bytes.Buffer)
+    } else {
+        return bytes.NewBuffer(make([]byte, 0, option.DefaultEncoderBufferSize))
+    }
+}
+
+func freeBytes(p []byte) {
+    p = p[:0]
+    bytesPool.Put(p)
+}
+
+func freeStack(p *_Stack) {
+    p.sp = 0
+    stackPool.Put(p)
+}
+
+func freeBuffer(p *bytes.Buffer) {
+    p.Reset()
+    bufferPool.Put(p)
+}
+
+func makeEncoder(vt *rt.GoType, ex ...interface{}) (interface{}, error) {
+    if pp, err := newCompiler().compile(vt.Pack(), ex[0].(bool)); err != nil {
+        return nil, err
+    } else {
+        as := newAssembler(pp)
+        as.name = vt.String()
+        return as.Load(), nil
+    }
+}
+
+func findOrCompile(vt *rt.GoType, pv bool) (_Encoder, error) {
+    if val := programCache.Get(vt); val != nil {
+        return val.(_Encoder), nil
+    } else if ret, err := programCache.Compute(vt, makeEncoder, pv); err == nil {
+        return ret.(_Encoder), nil
+    } else {
+        return nil, err
+    }
+}
+
+func pretouchType(_vt reflect.Type, opts option.CompileOptions, v uint8) (map[reflect.Type]uint8, error) {
+    /* compile function */
+    compiler := newCompiler().apply(opts)
+    encoder := func(vt *rt.GoType, ex ...interface{}) (interface{}, error) {
+        if pp, err := compiler.compile(_vt, ex[0].(bool)); err != nil {
+            return nil, err
+        } else {
+            as := newAssembler(pp)
+            as.name = vt.String()
+            return as.Load(), nil
+        }
+    }
+
+    /* find or compile */
+    vt := rt.UnpackType(_vt)
+    if val := programCache.Get(vt); val != nil {
+        return nil, nil
+    } else if _, err := programCache.Compute(vt, encoder, v == 1); err == nil {
+        return compiler.rec, nil
+    } else {
+        return nil, err
+    }
+}
+
+func pretouchRec(vtm map[reflect.Type]uint8, opts option.CompileOptions) error {
+    if opts.RecursiveDepth < 0 || len(vtm) == 0 {
+        return nil
+    }
+    next := make(map[reflect.Type]uint8)
+    for vt, v := range vtm {
+        sub, err := pretouchType(vt, opts, v)
+        if err != nil {
+            return err
+        }
+        for svt, v := range sub {
+            next[svt] = v
+        }
+    }
+    opts.RecursiveDepth -= 1
+    return pretouchRec(next, opts)
+}

vendor/github.com/bytedance/sonic/internal/encoder/primitives.go

@@ -0,0 +1,167 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding`
+    `encoding/json`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+/** Encoder Primitives **/
+
+func encodeNil(rb *[]byte) error {
+    *rb = append(*rb, 'n', 'u', 'l', 'l')
+    return nil
+}
+
+func encodeString(buf *[]byte, val string) error {
+    var sidx int
+    var pbuf *rt.GoSlice
+    var pstr *rt.GoString
+
+    /* opening quote */
+    *buf = append(*buf, '"')
+    pbuf = (*rt.GoSlice)(unsafe.Pointer(buf))
+    pstr = (*rt.GoString)(unsafe.Pointer(&val))
+
+    /* encode with native library */
+    for sidx < pstr.Len {
+        sn := pstr.Len - sidx
+        dn := pbuf.Cap - pbuf.Len
+        sp := padd(pstr.Ptr, sidx)
+        dp := padd(pbuf.Ptr, pbuf.Len)
+        nb := native.Quote(sp, sn, dp, &dn, 0)
+
+        /* check for errors */
+        if pbuf.Len += dn; nb >= 0 {
+            break
+        }
+
+        /* not enough space, grow the slice and try again */
+        sidx += ^nb
+        *pbuf = growslice(rt.UnpackType(byteType), *pbuf, pbuf.Cap * 2)
+    }
+
+    /* closing quote */
+    *buf = append(*buf, '"')
+    return nil
+}
+
+func encodeTypedPointer(buf *[]byte, vt *rt.GoType, vp *unsafe.Pointer, sb *_Stack, fv uint64) error {
+    if vt == nil {
+        return encodeNil(buf)
+    } else if fn, err := findOrCompile(vt, (fv&(1<<bitPointerValue)) != 0); err != nil {
+        return err
+    } else if vt.Indirect() {
+        rt.MoreStack(_FP_size + native.MaxFrameSize)
+        err := fn(buf, *vp, sb, fv)
+        return err
+    } else {
+        rt.MoreStack(_FP_size + native.MaxFrameSize)
+        err := fn(buf, unsafe.Pointer(vp), sb, fv)
+        return err
+    }
+}
+
+func encodeJsonMarshaler(buf *[]byte, val json.Marshaler, opt Options) error {
+    if ret, err := val.MarshalJSON(); err != nil {
+        return err
+    } else {
+        if opt & CompactMarshaler != 0 {
+            return compact(buf, ret)
+        }
+        if opt & NoValidateJSONMarshaler == 0 {
+            if ok, s := Valid(ret); !ok {
+                return error_marshaler(ret, s)
+            }
+        }
+        *buf = append(*buf, ret...)
+        return nil
+    }
+}
+
+func encodeTextMarshaler(buf *[]byte, val encoding.TextMarshaler, opt Options) error {
+    if ret, err := val.MarshalText(); err != nil {
+        return err
+    } else {
+        if opt & NoQuoteTextMarshaler != 0 {
+            *buf = append(*buf, ret...)
+            return nil
+        }
+        return encodeString(buf, rt.Mem2Str(ret) )
+    }
+}
+
+func htmlEscape(dst []byte, src []byte) []byte {
+    var sidx int
+
+    dst  = append(dst, src[:0]...) // avoid check nil dst
+    sbuf := (*rt.GoSlice)(unsafe.Pointer(&src))
+    dbuf := (*rt.GoSlice)(unsafe.Pointer(&dst))
+
+    /* grow dst if it is shorter */
+    if cap(dst) - len(dst) < len(src) + types.BufPaddingSize {
+        cap :=  len(src) * 3 / 2 + types.BufPaddingSize
+        *dbuf = growslice(typeByte, *dbuf, cap)
+    }
+
+    for sidx < sbuf.Len {
+        sp := padd(sbuf.Ptr, sidx)
+        dp := padd(dbuf.Ptr, dbuf.Len)
+
+        sn := sbuf.Len - sidx
+        dn := dbuf.Cap - dbuf.Len
+        nb := native.HTMLEscape(sp, sn, dp, &dn)
+
+        /* check for errors */
+        if dbuf.Len += dn; nb >= 0 {
+            break
+        }
+
+        /* not enough space, grow the slice and try again */
+        sidx += ^nb
+        *dbuf = growslice(typeByte, *dbuf, dbuf.Cap * 2)
+    }
+    return dst
+}
+
+var (
+    argPtrs   = []bool { true, true, true, false }
+    localPtrs = []bool{}
+)
+
+var (
+    _F_assertI2I = jit.Func(rt.AssertI2I2)
+)
+
+func asText(v unsafe.Pointer) (string, error) {
+    text := rt.AssertI2I2(_T_encoding_TextMarshaler, *(*rt.GoIface)(v))
+    r, e := (*(*encoding.TextMarshaler)(unsafe.Pointer(&text))).MarshalText()
+    return rt.Mem2Str(r), e
+}
+
+func asJson(v unsafe.Pointer) (string, error) {
+    text := rt.AssertI2I2(_T_json_Marshaler, *(*rt.GoIface)(v))
+    r, e := (*(*json.Marshaler)(unsafe.Pointer(&text))).MarshalJSON()
+    return rt.Mem2Str(r), e
+}

vendor/github.com/bytedance/sonic/internal/encoder/sort.go

@@ -0,0 +1,206 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+// Algorithm 3-way Radix Quicksort, d means the radix.
+// Reference: https://algs4.cs.princeton.edu/51radix/Quick3string.java.html
+func radixQsort(kvs []_MapPair, d, maxDepth int) {
+    for len(kvs) > 11 {
+        // To avoid the worst case of quickSort (time: O(n^2)), use introsort here.
+        // Reference: https://en.wikipedia.org/wiki/Introsort and
+        // https://github.com/golang/go/issues/467
+        if maxDepth == 0 {
+            heapSort(kvs, 0, len(kvs))
+            return
+        }
+        maxDepth--
+
+        p := pivot(kvs, d)
+        lt, i, gt := 0, 0, len(kvs)
+        for i < gt {
+            c := byteAt(kvs[i].k, d)
+            if c < p {
+                swap(kvs, lt, i)
+                i++
+                lt++
+            } else if c > p {
+                gt--
+                swap(kvs, i, gt)
+            } else {
+                i++
+            }
+        }
+
+        // kvs[0:lt] < v = kvs[lt:gt] < kvs[gt:len(kvs)]
+        // Native implemention:
+        //     radixQsort(kvs[:lt], d, maxDepth)
+        //     if p > -1 {
+        //         radixQsort(kvs[lt:gt], d+1, maxDepth)
+        //     }
+        //     radixQsort(kvs[gt:], d, maxDepth)
+        // Optimize as follows: make recursive calls only for the smaller parts.
+        // Reference: https://www.geeksforgeeks.org/quicksort-tail-call-optimization-reducing-worst-case-space-log-n/
+        if p == -1 {
+            if lt > len(kvs) - gt {
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[:lt]
+            } else {
+                radixQsort(kvs[:lt], d, maxDepth)
+                kvs = kvs[gt:]
+            }
+        } else {
+            ml := maxThree(lt, gt-lt, len(kvs)-gt)
+            if ml == lt {
+                radixQsort(kvs[lt:gt], d+1, maxDepth)
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[:lt]
+            } else if ml == gt-lt {
+                radixQsort(kvs[:lt], d, maxDepth)
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[lt:gt]
+                d += 1
+            } else {
+                radixQsort(kvs[:lt], d, maxDepth)
+                radixQsort(kvs[lt:gt], d+1, maxDepth)
+                kvs = kvs[gt:] 
+            }
+        }
+    }
+    insertRadixSort(kvs, d)
+}
+
+func insertRadixSort(kvs []_MapPair, d int) {
+    for i := 1; i < len(kvs); i++ {
+        for j := i; j > 0 && lessFrom(kvs[j].k, kvs[j-1].k, d); j-- {
+            swap(kvs, j, j-1)
+        }
+    }
+}
+
+func pivot(kvs []_MapPair, d int) int {
+    m := len(kvs) >> 1
+    if len(kvs) > 40 {
+        // Tukey's ``Ninther,'' median of three mediankvs of three.
+        t := len(kvs) / 8
+        return medianThree(
+            medianThree(byteAt(kvs[0].k, d), byteAt(kvs[t].k, d), byteAt(kvs[2*t].k, d)),
+            medianThree(byteAt(kvs[m].k, d), byteAt(kvs[m-t].k, d), byteAt(kvs[m+t].k, d)),
+            medianThree(byteAt(kvs[len(kvs)-1].k, d),
+                byteAt(kvs[len(kvs)-1-t].k, d),
+                byteAt(kvs[len(kvs)-1-2*t].k, d)))
+    }
+    return medianThree(byteAt(kvs[0].k, d), byteAt(kvs[m].k, d), byteAt(kvs[len(kvs)-1].k, d))
+}
+
+func medianThree(i, j, k int) int {
+    if i > j {
+        i, j = j, i
+    } // i < j
+    if k < i {
+        return i
+    }
+    if k > j {
+        return j
+    }
+    return k
+}
+
+func maxThree(i, j, k int) int {
+    max := i
+    if max < j {
+        max = j
+    }
+    if max < k {
+        max = k
+    }
+    return max
+}
+
+// maxDepth returns a threshold at which quicksort should switch
+// to heapsort. It returnkvs 2*ceil(lg(n+1)).
+func maxDepth(n int) int {
+    var depth int
+    for i := n; i > 0; i >>= 1 {
+        depth++
+    }
+    return depth * 2
+}
+
+// siftDown implements the heap property on kvs[lo:hi].
+// first is an offset into the array where the root of the heap lies.
+func siftDown(kvs []_MapPair, lo, hi, first int) {
+    root := lo
+    for {
+        child := 2*root + 1
+        if child >= hi {
+            break
+        }
+        if child+1 < hi && kvs[first+child].k < kvs[first+child+1].k {
+            child++
+        }
+        if kvs[first+root].k >= kvs[first+child].k {
+            return
+        }
+        swap(kvs, first+root, first+child)
+        root = child
+    }
+}
+
+func heapSort(kvs []_MapPair, a, b int) {
+    first := a
+    lo := 0
+    hi := b - a
+
+    // Build heap with the greatest element at top.
+    for i := (hi - 1) / 2; i >= 0; i-- {
+        siftDown(kvs, i, hi, first)
+    }
+
+    // Pop elements, the largest first, into end of kvs.
+    for i := hi - 1; i >= 0; i-- {
+        swap(kvs, first, first+i)
+        siftDown(kvs, lo, i, first)
+    }
+}
+
+// Note that _MapPair.k is NOT pointed to _MapPair.m when map key is integer after swap
+func swap(kvs []_MapPair, a, b int) {
+    kvs[a].k, kvs[b].k = kvs[b].k, kvs[a].k
+    kvs[a].v, kvs[b].v = kvs[b].v, kvs[a].v
+}
+
+// Compare two strings from the pos d.
+func lessFrom(a, b string, d int) bool {
+    l := len(a)
+    if l > len(b) {
+        l = len(b)
+    }
+    for i := d; i < l; i++ {
+        if a[i] == b[i] {
+            continue
+        }
+        return a[i] < b[i]
+    }
+    return len(a) < len(b)
+}
+
+func byteAt(b string, p int) int {
+    if p < len(b) {
+        return int(b[p])
+    }
+    return -1
+}

vendor/github.com/bytedance/sonic/internal/encoder/stream.go

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding/json`
+    `io`
+)
+
+// StreamEncoder uses io.Writer as input.
+type StreamEncoder struct {
+    w io.Writer
+    Encoder
+}
+
+// NewStreamEncoder adapts to encoding/json.NewDecoder API.
+//
+// NewStreamEncoder returns a new encoder that write to w.
+func NewStreamEncoder(w io.Writer) *StreamEncoder {
+    return &StreamEncoder{w: w}
+}
+
+// Encode encodes interface{} as JSON to io.Writer
+func (enc *StreamEncoder) Encode(val interface{}) (err error) {
+    buf := newBytes()
+    out := buf
+
+    /* encode into the buffer */
+    err = EncodeInto(&out, val, enc.Opts)
+    if err != nil {
+        goto free_bytes
+    }
+
+    if enc.indent != "" || enc.prefix != "" {
+        /* indent the JSON */
+        buf := newBuffer()
+        err = json.Indent(buf, out, enc.prefix, enc.indent)
+        if err != nil {
+            freeBuffer(buf)
+            goto free_bytes
+        }
+
+        // according to standard library, terminate each value with a newline...
+        if enc.Opts & NoEncoderNewline == 0 {
+            buf.WriteByte('\n')
+        }
+
+        /* copy into io.Writer */
+        _, err = io.Copy(enc.w, buf)
+        if err != nil {
+            freeBuffer(buf)
+            goto free_bytes
+        }
+
+    } else {
+        /* copy into io.Writer */
+        var n int
+        for len(out) > 0 {
+            n, err = enc.w.Write(out)
+            out = out[n:]
+            if err != nil {
+                goto free_bytes
+            }
+        }
+
+        // according to standard library, terminate each value with a newline...
+        if enc.Opts & NoEncoderNewline == 0 {
+            enc.w.Write([]byte{'\n'})
+        }
+    }
+
+free_bytes:
+    freeBytes(buf)
+    return err
+}

vendor/github.com/bytedance/sonic/internal/encoder/stubs_go116.go

@@ -0,0 +1,61 @@
+// +build go1.16,!go1.17
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `unsafe`
+
+    _ `github.com/cloudwego/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64encode github.com/cloudwego/base64x._subr__b64encode
+var _subr__b64encode uintptr
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname growslice runtime.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname mapiternext runtime.mapiternext
+//goland:noinspection GoUnusedParameter
+func mapiternext(it *rt.GoMapIterator)
+
+//go:linkname mapiterinit runtime.mapiterinit
+//goland:noinspection GoUnusedParameter
+func mapiterinit(t *rt.GoMapType, m *rt.GoMap, it *rt.GoMapIterator)
+
+//go:linkname isValidNumber encoding/json.isValidNumber
+//goland:noinspection GoUnusedParameter
+func isValidNumber(s string) bool
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+
+var _runtime_writeBarrier uintptr = rt.GcwbAddr()
+
+//go:linkname gcWriteBarrierAX runtime.gcWriteBarrier
+func gcWriteBarrierAX()

vendor/github.com/bytedance/sonic/internal/encoder/stubs_go117.go

@@ -0,0 +1,62 @@
+// +build go1.17,!go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `unsafe`
+
+    _ `github.com/cloudwego/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64encode github.com/cloudwego/base64x._subr__b64encode
+var _subr__b64encode uintptr
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname growslice runtime.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname mapiternext runtime.mapiternext
+//goland:noinspection GoUnusedParameter
+func mapiternext(it *rt.GoMapIterator)
+
+//go:linkname mapiterinit runtime.mapiterinit
+//goland:noinspection GoUnusedParameter
+func mapiterinit(t *rt.GoMapType, m *rt.GoMap, it *rt.GoMapIterator)
+
+//go:linkname isValidNumber encoding/json.isValidNumber
+//goland:noinspection GoUnusedParameter
+func isValidNumber(s string) bool
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+
+//go:linkname _runtime_writeBarrier runtime.writeBarrier
+var _runtime_writeBarrier uintptr
+
+//go:linkname gcWriteBarrierAX runtime.gcWriteBarrier
+func gcWriteBarrierAX()

vendor/github.com/bytedance/sonic/internal/encoder/stubs_go120.go

@@ -0,0 +1,62 @@
+// +build go1.20,!go1.21
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `unsafe`
+
+    _ `github.com/cloudwego/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64encode github.com/cloudwego/base64x._subr__b64encode
+var _subr__b64encode uintptr
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname growslice reflect.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname mapiternext runtime.mapiternext
+//goland:noinspection GoUnusedParameter
+func mapiternext(it *rt.GoMapIterator)
+
+//go:linkname mapiterinit runtime.mapiterinit
+//goland:noinspection GoUnusedParameter
+func mapiterinit(t *rt.GoMapType, m *rt.GoMap, it *rt.GoMapIterator)
+
+//go:linkname isValidNumber encoding/json.isValidNumber
+//goland:noinspection GoUnusedParameter
+func isValidNumber(s string) bool
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+
+//go:linkname _runtime_writeBarrier runtime.writeBarrier
+var _runtime_writeBarrier uintptr
+
+//go:linkname gcWriteBarrierAX runtime.gcWriteBarrier
+func gcWriteBarrierAX()

vendor/github.com/bytedance/sonic/internal/encoder/stubs_go121.go

@@ -0,0 +1,62 @@
+// +build go1.21
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `unsafe`
+
+    _ `github.com/cloudwego/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64encode github.com/cloudwego/base64x._subr__b64encode
+var _subr__b64encode uintptr
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname growslice reflect.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname mapiternext runtime.mapiternext
+//goland:noinspection GoUnusedParameter
+func mapiternext(it *rt.GoMapIterator)
+
+//go:linkname mapiterinit runtime.mapiterinit
+//goland:noinspection GoUnusedParameter
+func mapiterinit(t *rt.GoMapType, m *rt.GoMap, it *rt.GoMapIterator)
+
+//go:linkname isValidNumber encoding/json.isValidNumber
+//goland:noinspection GoUnusedParameter
+func isValidNumber(s string) bool
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+
+//go:linkname _runtime_writeBarrier runtime.writeBarrier
+var _runtime_writeBarrier uintptr
+
+//go:linkname gcWriteBarrier2 runtime.gcWriteBarrier2
+func gcWriteBarrier2()

vendor/github.com/bytedance/sonic/internal/encoder/types.go

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding`
+    `encoding/json`
+    `reflect`
+)
+
+var (
+    byteType                 = reflect.TypeOf(byte(0))
+    jsonNumberType           = reflect.TypeOf(json.Number(""))
+    jsonUnsupportedValueType = reflect.TypeOf(new(json.UnsupportedValueError))
+)
+
+var (
+    errorType                 = reflect.TypeOf((*error)(nil)).Elem()
+    jsonMarshalerType         = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
+    encodingTextMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
+)
+
+func isSimpleByte(vt reflect.Type) bool {
+    if vt.Kind() != byteType.Kind() {
+        return false
+    } else {
+        return !isEitherMarshaler(vt) && !isEitherMarshaler(reflect.PtrTo(vt))
+    }
+}
+
+func isEitherMarshaler(vt reflect.Type) bool {
+    return vt.Implements(jsonMarshalerType) || vt.Implements(encodingTextMarshalerType)
+}

vendor/github.com/bytedance/sonic/internal/encoder/utils.go

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding/json`
+    `unsafe`
+
+    `github.com/bytedance/sonic/loader`
+)
+
+//go:nosplit
+func padd(p unsafe.Pointer, v int) unsafe.Pointer {
+    return unsafe.Pointer(uintptr(p) + uintptr(v))
+}
+
+//go:nosplit
+func ptoenc(p loader.Function) _Encoder {
+    return *(*_Encoder)(unsafe.Pointer(&p))
+}
+
+func compact(p *[]byte, v []byte) error {
+    buf := newBuffer()
+    err := json.Compact(buf, v)
+
+    /* check for errors */
+    if err != nil {
+        return err
+    }
+
+    /* add to result */
+    v = buf.Bytes()
+    *p = append(*p, v...)
+
+    /* return the buffer into pool */
+    freeBuffer(buf)
+    return nil
+}

vendor/github.com/bytedance/sonic/internal/jit/arch_amd64.go

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package jit
+
+import (
+    `github.com/twitchyliquid64/golang-asm/asm/arch`
+    `github.com/twitchyliquid64/golang-asm/obj`
+)
+
+var (
+    _AC = arch.Set("amd64")
+)
+
+func As(op string) obj.As {
+    if ret, ok := _AC.Instructions[op]; ok {
+        return ret
+    } else {
+        panic("invalid instruction: " + op)
+    }
+}
+
+func Imm(imm int64) obj.Addr {
+    return obj.Addr {
+        Type   : obj.TYPE_CONST,
+        Offset : imm,
+    }
+}
+
+func Reg(reg string) obj.Addr {
+    if ret, ok := _AC.Register[reg]; ok {
+        return obj.Addr{Reg: ret, Type: obj.TYPE_REG}
+    } else {
+        panic("invalid register name: " + reg)
+    }
+}
+
+func Ptr(reg obj.Addr, offs int64) obj.Addr {
+    return obj.Addr {
+        Reg    : reg.Reg,
+        Type   : obj.TYPE_MEM,
+        Offset : offs,
+    }
+}
+
+func Sib(reg obj.Addr, idx obj.Addr, scale int16, offs int64) obj.Addr {
+    return obj.Addr {
+        Reg    : reg.Reg,
+        Index  : idx.Reg,
+        Scale  : scale,
+        Type   : obj.TYPE_MEM,
+        Offset : offs,
+    }
+}

vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go

@@ -0,0 +1,269 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package jit
+
+import (
+    `encoding/binary`
+    `strconv`
+    `strings`
+    `sync`
+
+    `github.com/bytedance/sonic/loader`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+const (
+    _LB_jump_pc = "_jump_pc_"
+)
+
+type BaseAssembler struct {
+    i        int
+    f        func()
+    c        []byte
+    o        sync.Once
+    pb       *Backend
+    xrefs    map[string][]*obj.Prog
+    labels   map[string]*obj.Prog
+    pendings map[string][]*obj.Prog
+}
+
+/** Instruction Encoders **/
+
+var _NOPS = [][16]byte {
+    {0x90},                                                     // NOP
+    {0x66, 0x90},                                               // 66 NOP
+    {0x0f, 0x1f, 0x00},                                         // NOP DWORD ptr [EAX]
+    {0x0f, 0x1f, 0x40, 0x00},                                   // NOP DWORD ptr [EAX + 00H]
+    {0x0f, 0x1f, 0x44, 0x00, 0x00},                             // NOP DWORD ptr [EAX + EAX*1 + 00H]
+    {0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00},                       // 66 NOP DWORD ptr [EAX + EAX*1 + 00H]
+    {0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00},                 // NOP DWORD ptr [EAX + 00000000H]
+    {0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},           // NOP DWORD ptr [EAX + EAX*1 + 00000000H]
+    {0x66, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},     // 66 NOP DWORD ptr [EAX + EAX*1 + 00000000H]
+}
+
+func (self *BaseAssembler) NOP() *obj.Prog {
+    p := self.pb.New()
+    p.As = obj.ANOP
+    self.pb.Append(p)
+    return p
+}
+
+func (self *BaseAssembler) NOPn(n int) {
+    for i := len(_NOPS); i > 0 && n > 0; i-- {
+        for ; n >= i; n -= i {
+            self.Byte(_NOPS[i - 1][:i]...)
+        }
+    }
+}
+
+func (self *BaseAssembler) Byte(v ...byte) {
+    for ; len(v) >= 8; v = v[8:] { self.From("QUAD", Imm(rt.Get64(v))) }
+    for ; len(v) >= 4; v = v[4:] { self.From("LONG", Imm(int64(rt.Get32(v)))) }
+    for ; len(v) >= 2; v = v[2:] { self.From("WORD", Imm(int64(rt.Get16(v)))) }
+    for ; len(v) >= 1; v = v[1:] { self.From("BYTE", Imm(int64(v[0]))) }
+}
+
+func (self *BaseAssembler) Mark(pc int) {
+    self.i++
+    self.Link(_LB_jump_pc + strconv.Itoa(pc))
+}
+
+func (self *BaseAssembler) Link(to string) {
+    var p *obj.Prog
+    var v []*obj.Prog
+
+    /* placeholder substitution */
+    if strings.Contains(to, "{n}") {
+        to = strings.ReplaceAll(to, "{n}", strconv.Itoa(self.i))
+    }
+
+    /* check for duplications */
+    if _, ok := self.labels[to]; ok {
+        panic("label " + to + " has already been linked")
+    }
+
+    /* get the pending links */
+    p = self.NOP()
+    v = self.pendings[to]
+
+    /* patch all the pending jumps */
+    for _, q := range v {
+        q.To.Val = p
+    }
+
+    /* mark the label as resolved */
+    self.labels[to] = p
+    delete(self.pendings, to)
+}
+
+func (self *BaseAssembler) Xref(pc int, d int64) {
+    self.Sref(_LB_jump_pc + strconv.Itoa(pc), d)
+}
+
+func (self *BaseAssembler) Sref(to string, d int64) {
+    p := self.pb.New()
+    p.As = x86.ALONG
+    p.From = Imm(-d)
+
+    /* placeholder substitution */
+    if strings.Contains(to, "{n}") {
+        to = strings.ReplaceAll(to, "{n}", strconv.Itoa(self.i))
+    }
+
+    /* record the patch point */
+    self.pb.Append(p)
+    self.xrefs[to] = append(self.xrefs[to], p)
+}
+
+func (self *BaseAssembler) Xjmp(op string, to int) {
+    self.Sjmp(op, _LB_jump_pc + strconv.Itoa(to))
+}
+
+func (self *BaseAssembler) Sjmp(op string, to string) {
+    p := self.pb.New()
+    p.As = As(op)
+
+    /* placeholder substitution */
+    if strings.Contains(to, "{n}") {
+        to = strings.ReplaceAll(to, "{n}", strconv.Itoa(self.i))
+    }
+
+    /* check for backward jumps */
+    if v, ok := self.labels[to]; ok {
+        p.To.Val = v
+    } else {
+        self.pendings[to] = append(self.pendings[to], p)
+    }
+
+    /* mark as a branch, and add to instruction buffer */
+    p.To.Type = obj.TYPE_BRANCH
+    self.pb.Append(p)
+}
+
+func (self *BaseAssembler) Rjmp(op string, to obj.Addr) {
+    p := self.pb.New()
+    p.To = to
+    p.As = As(op)
+    self.pb.Append(p)
+}
+
+func (self *BaseAssembler) From(op string, val obj.Addr) {
+    p := self.pb.New()
+    p.As = As(op)
+    p.From = val
+    self.pb.Append(p)
+}
+
+func (self *BaseAssembler) Emit(op string, args ...obj.Addr) {
+    p := self.pb.New()
+    p.As = As(op)
+    self.assignOperands(p, args)
+    self.pb.Append(p)
+}
+
+func (self *BaseAssembler) assignOperands(p *obj.Prog, args []obj.Addr) {
+    switch len(args) {
+        case 0  :
+        case 1  : p.To                     = args[0]
+        case 2  : p.To, p.From             = args[1], args[0]
+        case 3  : p.To, p.From, p.RestArgs = args[2], args[0], args[1:2]
+        case 4  : p.To, p.From, p.RestArgs = args[2], args[3], args[:2]
+        default : panic("invalid operands")
+    }
+}
+
+/** Assembler Helpers **/
+
+func (self *BaseAssembler) Size() int {
+    self.build()
+    return len(self.c)
+}
+
+func (self *BaseAssembler) Init(f func()) {
+    self.i = 0
+    self.f = f
+    self.c = nil
+    self.o = sync.Once{}
+}
+
+var jitLoader = loader.Loader{
+    Name: "sonic.jit.",
+    File: "github.com/bytedance/sonic/jit.go",
+    Options: loader.Options{
+        NoPreempt: true,
+    },
+}
+
+func (self *BaseAssembler) Load(name string, frameSize int, argSize int, argStackmap []bool, localStackmap []bool) loader.Function {
+    self.build()
+    return jitLoader.LoadOne(self.c, name, frameSize, argSize, argStackmap, localStackmap)
+}
+
+/** Assembler Stages **/
+
+func (self *BaseAssembler) init() {
+    self.pb       = newBackend("amd64")
+    self.xrefs    = map[string][]*obj.Prog{}
+    self.labels   = map[string]*obj.Prog{}
+    self.pendings = map[string][]*obj.Prog{}
+}
+
+func (self *BaseAssembler) build() {
+    self.o.Do(func() {
+        self.init()
+        self.f()
+        self.validate()
+        self.assemble()
+        self.resolve()
+        self.release()
+    })
+}
+
+func (self *BaseAssembler) release() {
+    self.pb.Release()
+    self.pb = nil
+    self.xrefs = nil
+    self.labels = nil
+    self.pendings = nil
+}
+
+func (self *BaseAssembler) resolve() {
+    for s, v := range self.xrefs {
+        for _, prog := range v {
+            if prog.As != x86.ALONG {
+                panic("invalid RIP relative reference")
+            } else if p, ok := self.labels[s]; !ok {
+                panic("links are not fully resolved: " + s)
+            } else {
+                off := prog.From.Offset + p.Pc - prog.Pc
+                binary.LittleEndian.PutUint32(self.c[prog.Pc:], uint32(off))
+            }
+        }
+    }
+}
+
+func (self *BaseAssembler) validate() {
+    for key := range self.pendings {
+        panic("links are not fully resolved: " + key)
+    }
+}
+
+func (self *BaseAssembler) assemble() {
+    self.c = self.pb.Assemble()
+}

vendor/github.com/bytedance/sonic/internal/jit/backend.go

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package jit
+
+import (
+    `fmt`
+    `sync`
+    _ `unsafe`
+
+    `github.com/twitchyliquid64/golang-asm/asm/arch`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/objabi`
+)
+
+type Backend struct {
+    Ctxt *obj.Link
+    Arch *arch.Arch
+    Head *obj.Prog
+    Tail *obj.Prog
+    Prog []*obj.Prog
+}
+
+var (
+    _progPool sync.Pool
+)
+
+//go:nosplit
+//go:linkname throw runtime.throw
+func throw(_ string)
+
+func newProg() *obj.Prog {
+    if val := _progPool.Get(); val == nil {
+        return new(obj.Prog)
+    } else {
+        return remProg(val.(*obj.Prog))
+    }
+}
+
+func remProg(p *obj.Prog) *obj.Prog {
+    *p = obj.Prog{}
+    return p
+}
+
+func newBackend(name string) (ret *Backend) {
+    ret      = new(Backend)
+    ret.Arch = arch.Set(name)
+    ret.Ctxt = newLinkContext(ret.Arch.LinkArch)
+    ret.Arch.Init(ret.Ctxt)
+    return
+}
+
+func newLinkContext(arch *obj.LinkArch) (ret *obj.Link) {
+    ret          = obj.Linknew(arch)
+    ret.Headtype = objabi.Hlinux
+    ret.DiagFunc = diagLinkContext
+    return
+}
+
+func diagLinkContext(str string, args ...interface{}) {
+    throw(fmt.Sprintf(str, args...))
+}
+
+func (self *Backend) New() (ret *obj.Prog) {
+    ret = newProg()
+    ret.Ctxt = self.Ctxt
+    self.Prog = append(self.Prog, ret)
+    return
+}
+
+func (self *Backend) Append(p *obj.Prog) {
+    if self.Head == nil {
+        self.Head = p
+        self.Tail = p
+    } else {
+        self.Tail.Link = p
+        self.Tail = p
+    }
+}
+
+func (self *Backend) Release() {
+    self.Arch = nil
+    self.Ctxt = nil
+
+    /* return all the progs into pool */
+    for _, p := range self.Prog {
+        _progPool.Put(p)
+    }
+
+    /* clear all the references */
+    self.Head = nil
+    self.Tail = nil
+    self.Prog = nil
+}
+
+func (self *Backend) Assemble() []byte {
+    var sym obj.LSym
+    var fnv obj.FuncInfo
+
+    /* construct the function */
+    sym.Func = &fnv
+    fnv.Text = self.Head
+
+    /* call the assembler */
+    self.Arch.Assemble(self.Ctxt, &sym, self.New)
+    return sym.P
+}

vendor/github.com/bytedance/sonic/internal/jit/runtime.go

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package jit
+
+import (
+    `reflect`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/twitchyliquid64/golang-asm/obj`
+)
+
+func Func(f interface{}) obj.Addr {
+    if p := rt.UnpackEface(f); p.Type.Kind() != reflect.Func {
+        panic("f is not a function")
+    } else {
+        return Imm(*(*int64)(p.Value))
+    }
+}
+
+func Type(t reflect.Type) obj.Addr {
+    return Gtype(rt.UnpackType(t))
+}
+
+func Itab(i *rt.GoType, t reflect.Type) obj.Addr {
+    return Imm(int64(uintptr(unsafe.Pointer(rt.Getitab(rt.IfaceType(i), rt.UnpackType(t), false)))))
+}
+
+func Gitab(i *rt.GoItab) obj.Addr {
+    return Imm(int64(uintptr(unsafe.Pointer(i))))
+}
+
+func Gtype(t *rt.GoType) obj.Addr {
+    return Imm(int64(uintptr(unsafe.Pointer(t))))
+}

vendor/github.com/bytedance/sonic/internal/native/avx/f32toa.go

@@ -0,0 +1,36 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_f32toa func(out *byte, val float32) (ret int) 
+
+var S_f32toa uintptr
+
+//go:nosplit
+func f32toa(out *byte, val float32) (ret int) {
+    return F_f32toa((*byte)(rt.NoEscape(unsafe.Pointer(out))), val)
+}

vendor/github.com/bytedance/sonic/internal/native/avx/f32toa_subr.go

@@ -0,0 +1,44 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__f32toa = 32
+)
+
+const (
+    _stack__f32toa = 48
+)
+
+const (
+    _size__f32toa = 3392
+)
+
+var (
+    _pcsp__f32toa = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {3350, 48},
+        {3351, 40},
+        {3353, 32},
+        {3355, 24},
+        {3357, 16},
+        {3359, 8},
+        {3363, 0},
+        {3385, 48},
+    }
+)
+
+var _cfunc_f32toa = []loader.CFunc{
+    {"_f32toa_entry", 0,  _entry__f32toa, 0, nil},
+    {"_f32toa", _entry__f32toa, _size__f32toa, _stack__f32toa, _pcsp__f32toa},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/f32toa_text_amd64.go

@@ -0,0 +1,964 @@
+// +build amd64
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+var _text_f32toa = []byte{
+	// .p2align 5, 0x00
+	// LCPI0_0
+	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, // QUAD $0x3030303030303030; QUAD $0x3030303030303030  // .space 16, '0000000000000000'
+	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, //0x00000010 QUAD $0x3030303030303030; QUAD $0x3030303030303030  // .space 16, '0000000000000000'
+	//0x00000020 .p2align 4, 0x90
+	//0x00000020 _f32toa
+	0x55, //0x00000020 pushq        %rbp
+	0x48, 0x89, 0xe5, //0x00000021 movq         %rsp, %rbp
+	0x41, 0x57, //0x00000024 pushq        %r15
+	0x41, 0x56, //0x00000026 pushq        %r14
+	0x41, 0x55, //0x00000028 pushq        %r13
+	0x41, 0x54, //0x0000002a pushq        %r12
+	0x53, //0x0000002c pushq        %rbx
+	0xc5, 0xf9, 0x7e, 0xc0, //0x0000002d vmovd        %xmm0, %eax
+	0x89, 0xc1, //0x00000031 movl         %eax, %ecx
+	0xc1, 0xe9, 0x17, //0x00000033 shrl         $23, %ecx
+	0x0f, 0xb6, 0xd9, //0x00000036 movzbl       %cl, %ebx
+	0x81, 0xfb, 0xff, 0x00, 0x00, 0x00, //0x00000039 cmpl         $255, %ebx
+	0x0f, 0x84, 0xff, 0x0c, 0x00, 0x00, //0x0000003f je           LBB0_139
+	0xc6, 0x07, 0x2d, //0x00000045 movb         $45, (%rdi)
+	0x41, 0x89, 0xc1, //0x00000048 movl         %eax, %r9d
+	0x41, 0xc1, 0xe9, 0x1f, //0x0000004b shrl         $31, %r9d
+	0x4e, 0x8d, 0x04, 0x0f, //0x0000004f leaq         (%rdi,%r9), %r8
+	0xa9, 0xff, 0xff, 0xff, 0x7f, //0x00000053 testl        $2147483647, %eax
+	0x0f, 0x84, 0xc6, 0x01, 0x00, 0x00, //0x00000058 je           LBB0_14
+	0x25, 0xff, 0xff, 0x7f, 0x00, //0x0000005e andl         $8388607, %eax
+	0x85, 0xdb, //0x00000063 testl        %ebx, %ebx
+	0x0f, 0x84, 0xe1, 0x0c, 0x00, 0x00, //0x00000065 je           LBB0_140
+	0x8d, 0xb0, 0x00, 0x00, 0x80, 0x00, //0x0000006b leal         $8388608(%rax), %esi
+	0x44, 0x8d, 0xbb, 0x6a, 0xff, 0xff, 0xff, //0x00000071 leal         $-150(%rbx), %r15d
+	0x8d, 0x4b, 0x81, //0x00000078 leal         $-127(%rbx), %ecx
+	0x83, 0xf9, 0x17, //0x0000007b cmpl         $23, %ecx
+	0x0f, 0x87, 0x1b, 0x00, 0x00, 0x00, //0x0000007e ja           LBB0_5
+	0xb9, 0x96, 0x00, 0x00, 0x00, //0x00000084 movl         $150, %ecx
+	0x29, 0xd9, //0x00000089 subl         %ebx, %ecx
+	0x48, 0xc7, 0xc2, 0xff, 0xff, 0xff, 0xff, //0x0000008b movq         $-1, %rdx
+	0x48, 0xd3, 0xe2, //0x00000092 shlq         %cl, %rdx
+	0xf7, 0xd2, //0x00000095 notl         %edx
+	0x85, 0xf2, //0x00000097 testl        %esi, %edx
+	0x0f, 0x84, 0x12, 0x04, 0x00, 0x00, //0x00000099 je           LBB0_32
+	//0x0000009f LBB0_5
+	0x41, 0x89, 0xf6, //0x0000009f movl         %esi, %r14d
+	0x41, 0x83, 0xe6, 0x01, //0x000000a2 andl         $1, %r14d
+	0x85, 0xc0, //0x000000a6 testl        %eax, %eax
+	0x0f, 0x94, 0xc0, //0x000000a8 sete         %al
+	0x83, 0xfb, 0x01, //0x000000ab cmpl         $1, %ebx
+	0x0f, 0x97, 0xc1, //0x000000ae seta         %cl
+	0x20, 0xc1, //0x000000b1 andb         %al, %cl
+	0x0f, 0xb6, 0xc9, //0x000000b3 movzbl       %cl, %ecx
+	0x41, 0x89, 0xf2, //0x000000b6 movl         %esi, %r10d
+	0x41, 0xc1, 0xe2, 0x02, //0x000000b9 shll         $2, %r10d
+	0x8d, 0x44, 0xb1, 0xfe, //0x000000bd leal         $-2(%rcx,%rsi,4), %eax
+	0x45, 0x69, 0xdf, 0x13, 0x44, 0x13, 0x00, //0x000000c1 imull        $1262611, %r15d, %r11d
+	0x31, 0xd2, //0x000000c8 xorl         %edx, %edx
+	0x84, 0xc9, //0x000000ca testb        %cl, %cl
+	0xb9, 0xff, 0xfe, 0x07, 0x00, //0x000000cc movl         $524031, %ecx
+	0x0f, 0x44, 0xca, //0x000000d1 cmovel       %edx, %ecx
+	0x41, 0x29, 0xcb, //0x000000d4 subl         %ecx, %r11d
+	0x41, 0xc1, 0xfb, 0x16, //0x000000d7 sarl         $22, %r11d
+	0x41, 0x69, 0xcb, 0xb1, 0x6c, 0xe5, 0xff, //0x000000db imull        $-1741647, %r11d, %ecx
+	0xc1, 0xe9, 0x13, //0x000000e2 shrl         $19, %ecx
+	0x44, 0x01, 0xf9, //0x000000e5 addl         %r15d, %ecx
+	0xba, 0x1f, 0x00, 0x00, 0x00, //0x000000e8 movl         $31, %edx
+	0x44, 0x29, 0xda, //0x000000ed subl         %r11d, %edx
+	0x48, 0x63, 0xd2, //0x000000f0 movslq       %edx, %rdx
+	0x48, 0x8d, 0x1d, 0x36, 0x0d, 0x00, 0x00, //0x000000f3 leaq         $3382(%rip), %rbx  /* _pow10_ceil_sig_f32.g+0(%rip) */
+	0xfe, 0xc1, //0x000000fa incb         %cl
+	0xd3, 0xe0, //0x000000fc shll         %cl, %eax
+	0x4c, 0x8b, 0x24, 0xd3, //0x000000fe movq         (%rbx,%rdx,8), %r12
+	0x49, 0xf7, 0xe4, //0x00000102 mulq         %r12
+	0x48, 0xc1, 0xe8, 0x20, //0x00000105 shrq         $32, %rax
+	0x31, 0xdb, //0x00000109 xorl         %ebx, %ebx
+	0x83, 0xf8, 0x01, //0x0000010b cmpl         $1, %eax
+	0x0f, 0x97, 0xc3, //0x0000010e seta         %bl
+	0x41, 0xd3, 0xe2, //0x00000111 shll         %cl, %r10d
+	0x09, 0xd3, //0x00000114 orl          %edx, %ebx
+	0x4c, 0x89, 0xd0, //0x00000116 movq         %r10, %rax
+	0x49, 0xf7, 0xe4, //0x00000119 mulq         %r12
+	0x49, 0x89, 0xd2, //0x0000011c movq         %rdx, %r10
+	0x48, 0xc1, 0xe8, 0x20, //0x0000011f shrq         $32, %rax
+	0x45, 0x31, 0xff, //0x00000123 xorl         %r15d, %r15d
+	0x83, 0xf8, 0x01, //0x00000126 cmpl         $1, %eax
+	0x41, 0x0f, 0x97, 0xc7, //0x00000129 seta         %r15b
+	0x8d, 0x04, 0xb5, 0x02, 0x00, 0x00, 0x00, //0x0000012d leal         $2(,%rsi,4), %eax
+	0xd3, 0xe0, //0x00000134 shll         %cl, %eax
+	0x45, 0x09, 0xd7, //0x00000136 orl          %r10d, %r15d
+	0x49, 0xf7, 0xe4, //0x00000139 mulq         %r12
+	0x48, 0xc1, 0xe8, 0x20, //0x0000013c shrq         $32, %rax
+	0x31, 0xc9, //0x00000140 xorl         %ecx, %ecx
+	0x83, 0xf8, 0x01, //0x00000142 cmpl         $1, %eax
+	0x0f, 0x97, 0xc1, //0x00000145 seta         %cl
+	0x09, 0xd1, //0x00000148 orl          %edx, %ecx
+	0x44, 0x01, 0xf3, //0x0000014a addl         %r14d, %ebx
+	0x44, 0x29, 0xf1, //0x0000014d subl         %r14d, %ecx
+	0x41, 0x83, 0xff, 0x28, //0x00000150 cmpl         $40, %r15d
+	0x0f, 0x82, 0x9a, 0x00, 0x00, 0x00, //0x00000154 jb           LBB0_12
+	0x44, 0x89, 0xd2, //0x0000015a movl         %r10d, %edx
+	0xb8, 0xcd, 0xcc, 0xcc, 0xcc, //0x0000015d movl         $3435973837, %eax
+	0x48, 0x0f, 0xaf, 0xc2, //0x00000162 imulq        %rdx, %rax
+	0x48, 0xc1, 0xe8, 0x25, //0x00000166 shrq         $37, %rax
+	0x41, 0x89, 0xde, //0x0000016a movl         %ebx, %r14d
+	0x48, 0x8d, 0x34, 0xc5, 0x00, 0x00, 0x00, 0x00, //0x0000016d leaq         (,%rax,8), %rsi
+	0x48, 0x8d, 0x14, 0xb6, //0x00000175 leaq         (%rsi,%rsi,4), %rdx
+	0x4c, 0x39, 0xf2, //0x00000179 cmpq         %r14, %rdx
+	0x41, 0x0f, 0x93, 0xc4, //0x0000017c setae        %r12b
+	0x4c, 0x8d, 0x74, 0xb6, 0x28, //0x00000180 leaq         $40(%rsi,%rsi,4), %r14
+	0x89, 0xce, //0x00000185 movl         %ecx, %esi
+	0x49, 0x39, 0xf6, //0x00000187 cmpq         %rsi, %r14
+	0x0f, 0x96, 0xc2, //0x0000018a setbe        %dl
+	0x41, 0x38, 0xd4, //0x0000018d cmpb         %dl, %r12b
+	0x0f, 0x84, 0x5e, 0x00, 0x00, 0x00, //0x00000190 je           LBB0_12
+	0x45, 0x31, 0xed, //0x00000196 xorl         %r13d, %r13d
+	0x49, 0x39, 0xf6, //0x00000199 cmpq         %rsi, %r14
+	0x41, 0x0f, 0x96, 0xc5, //0x0000019c setbe        %r13b
+	0x41, 0x01, 0xc5, //0x000001a0 addl         %eax, %r13d
+	0x41, 0xff, 0xc3, //0x000001a3 incl         %r11d
+	0x41, 0x81, 0xfd, 0xa0, 0x86, 0x01, 0x00, //0x000001a6 cmpl         $100000, %r13d
+	0x0f, 0x83, 0xb0, 0x00, 0x00, 0x00, //0x000001ad jae          LBB0_18
+	//0x000001b3 LBB0_8
+	0xb8, 0x01, 0x00, 0x00, 0x00, //0x000001b3 movl         $1, %eax
+	0x41, 0x83, 0xfd, 0x0a, //0x000001b8 cmpl         $10, %r13d
+	0x0f, 0x82, 0xd4, 0x00, 0x00, 0x00, //0x000001bc jb           LBB0_22
+	0xb8, 0x02, 0x00, 0x00, 0x00, //0x000001c2 movl         $2, %eax
+	0x41, 0x83, 0xfd, 0x64, //0x000001c7 cmpl         $100, %r13d
+	0x0f, 0x82, 0xc5, 0x00, 0x00, 0x00, //0x000001cb jb           LBB0_22
+	0xb8, 0x03, 0x00, 0x00, 0x00, //0x000001d1 movl         $3, %eax
+	0x41, 0x81, 0xfd, 0xe8, 0x03, 0x00, 0x00, //0x000001d6 cmpl         $1000, %r13d
+	0x0f, 0x82, 0xb3, 0x00, 0x00, 0x00, //0x000001dd jb           LBB0_22
+	0x41, 0x81, 0xfd, 0x10, 0x27, 0x00, 0x00, //0x000001e3 cmpl         $10000, %r13d
+	0xb8, 0x05, 0x00, 0x00, 0x00, //0x000001ea movl         $5, %eax
+	0xe9, 0x9f, 0x00, 0x00, 0x00, //0x000001ef jmp          LBB0_21
+	//0x000001f4 LBB0_12
+	0x4d, 0x89, 0xd6, //0x000001f4 movq         %r10, %r14
+	0x49, 0xc1, 0xee, 0x02, //0x000001f7 shrq         $2, %r14
+	0x44, 0x89, 0xd6, //0x000001fb movl         %r10d, %esi
+	0x83, 0xe6, 0xfc, //0x000001fe andl         $-4, %esi
+	0x39, 0xf3, //0x00000201 cmpl         %esi, %ebx
+	0x0f, 0x96, 0xc2, //0x00000203 setbe        %dl
+	0x8d, 0x5e, 0x04, //0x00000206 leal         $4(%rsi), %ebx
+	0x39, 0xcb, //0x00000209 cmpl         %ecx, %ebx
+	0x0f, 0x96, 0xc0, //0x0000020b setbe        %al
+	0x38, 0xc2, //0x0000020e cmpb         %al, %dl
+	0x0f, 0x84, 0x1d, 0x00, 0x00, 0x00, //0x00000210 je           LBB0_15
+	0x45, 0x31, 0xed, //0x00000216 xorl         %r13d, %r13d
+	0x39, 0xcb, //0x00000219 cmpl         %ecx, %ebx
+	0x41, 0x0f, 0x96, 0xc5, //0x0000021b setbe        %r13b
+	0xe9, 0x2f, 0x00, 0x00, 0x00, //0x0000021f jmp          LBB0_17
+	//0x00000224 LBB0_14
+	0x41, 0xc6, 0x00, 0x30, //0x00000224 movb         $48, (%r8)
+	0x41, 0x29, 0xf8, //0x00000228 subl         %edi, %r8d
+	0x41, 0xff, 0xc0, //0x0000022b incl         %r8d
+	0xe9, 0x00, 0x0b, 0x00, 0x00, //0x0000022e jmp          LBB0_138
+	//0x00000233 LBB0_15
+	0x83, 0xce, 0x02, //0x00000233 orl          $2, %esi
+	0x41, 0xbd, 0x01, 0x00, 0x00, 0x00, //0x00000236 movl         $1, %r13d
+	0x41, 0x39, 0xf7, //0x0000023c cmpl         %esi, %r15d
+	0x0f, 0x87, 0x0e, 0x00, 0x00, 0x00, //0x0000023f ja           LBB0_17
+	0x0f, 0x94, 0xc0, //0x00000245 sete         %al
+	0x41, 0xc0, 0xea, 0x02, //0x00000248 shrb         $2, %r10b
+	0x41, 0x20, 0xc2, //0x0000024c andb         %al, %r10b
+	0x45, 0x0f, 0xb6, 0xea, //0x0000024f movzbl       %r10b, %r13d
+	//0x00000253 LBB0_17
+	0x45, 0x01, 0xf5, //0x00000253 addl         %r14d, %r13d
+	0x41, 0x81, 0xfd, 0xa0, 0x86, 0x01, 0x00, //0x00000256 cmpl         $100000, %r13d
+	0x0f, 0x82, 0x50, 0xff, 0xff, 0xff, //0x0000025d jb           LBB0_8
+	//0x00000263 LBB0_18
+	0xb8, 0x06, 0x00, 0x00, 0x00, //0x00000263 movl         $6, %eax
+	0x41, 0x81, 0xfd, 0x40, 0x42, 0x0f, 0x00, //0x00000268 cmpl         $1000000, %r13d
+	0x0f, 0x82, 0x21, 0x00, 0x00, 0x00, //0x0000026f jb           LBB0_22
+	0xb8, 0x07, 0x00, 0x00, 0x00, //0x00000275 movl         $7, %eax
+	0x41, 0x81, 0xfd, 0x80, 0x96, 0x98, 0x00, //0x0000027a cmpl         $10000000, %r13d
+	0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x00000281 jb           LBB0_22
+	0x41, 0x81, 0xfd, 0x00, 0xe1, 0xf5, 0x05, //0x00000287 cmpl         $100000000, %r13d
+	0xb8, 0x09, 0x00, 0x00, 0x00, //0x0000028e movl         $9, %eax
+	//0x00000293 LBB0_21
+	0x83, 0xd8, 0x00, //0x00000293 sbbl         $0, %eax
+	//0x00000296 LBB0_22
+	0x46, 0x8d, 0x3c, 0x18, //0x00000296 leal         (%rax,%r11), %r15d
+	0x42, 0x8d, 0x4c, 0x18, 0x05, //0x0000029a leal         $5(%rax,%r11), %ecx
+	0x83, 0xf9, 0x1b, //0x0000029f cmpl         $27, %ecx
+	0x0f, 0x82, 0x77, 0x00, 0x00, 0x00, //0x000002a2 jb           LBB0_26
+	0x89, 0xc0, //0x000002a8 movl         %eax, %eax
+	0x49, 0x8d, 0x5c, 0x00, 0x01, //0x000002aa leaq         $1(%r8,%rax), %rbx
+	0x41, 0x81, 0xfd, 0x10, 0x27, 0x00, 0x00, //0x000002af cmpl         $10000, %r13d
+	0x0f, 0x82, 0xd9, 0x00, 0x00, 0x00, //0x000002b6 jb           LBB0_30
+	0x44, 0x89, 0xe8, //0x000002bc movl         %r13d, %eax
+	0x41, 0xbb, 0x59, 0x17, 0xb7, 0xd1, //0x000002bf movl         $3518437209, %r11d
+	0x4c, 0x0f, 0xaf, 0xd8, //0x000002c5 imulq        %rax, %r11
+	0x49, 0xc1, 0xeb, 0x2d, //0x000002c9 shrq         $45, %r11
+	0x41, 0x69, 0xc3, 0xf0, 0xd8, 0xff, 0xff, //0x000002cd imull        $-10000, %r11d, %eax
+	0x44, 0x01, 0xe8, //0x000002d4 addl         %r13d, %eax
+	0x0f, 0x84, 0xb3, 0x04, 0x00, 0x00, //0x000002d7 je           LBB0_62
+	0x89, 0xc1, //0x000002dd movl         %eax, %ecx
+	0x48, 0x69, 0xc9, 0x1f, 0x85, 0xeb, 0x51, //0x000002df imulq        $1374389535, %rcx, %rcx
+	0x48, 0xc1, 0xe9, 0x25, //0x000002e6 shrq         $37, %rcx
+	0x6b, 0xd1, 0x64, //0x000002ea imull        $100, %ecx, %edx
+	0x29, 0xd0, //0x000002ed subl         %edx, %eax
+	0x48, 0x8d, 0x15, 0x6a, 0x0a, 0x00, 0x00, //0x000002ef leaq         $2666(%rip), %rdx  /* _Digits+0(%rip) */
+	0x0f, 0xb7, 0x04, 0x42, //0x000002f6 movzwl       (%rdx,%rax,2), %eax
+	0x66, 0x89, 0x43, 0xfe, //0x000002fa movw         %ax, $-2(%rbx)
+	0x0f, 0xb7, 0x04, 0x4a, //0x000002fe movzwl       (%rdx,%rcx,2), %eax
+	0x66, 0x89, 0x43, 0xfc, //0x00000302 movw         %ax, $-4(%rbx)
+	0x45, 0x31, 0xc9, //0x00000306 xorl         %r9d, %r9d
+	0x48, 0x8d, 0x4b, 0xfc, //0x00000309 leaq         $-4(%rbx), %rcx
+	0x41, 0x83, 0xfb, 0x64, //0x0000030d cmpl         $100, %r11d
+	0x0f, 0x83, 0x91, 0x00, 0x00, 0x00, //0x00000311 jae          LBB0_64
+	//0x00000317 LBB0_31
+	0x44, 0x89, 0xda, //0x00000317 movl         %r11d, %edx
+	0xe9, 0xd4, 0x00, 0x00, 0x00, //0x0000031a jmp          LBB0_66
+	//0x0000031f LBB0_26
+	0x41, 0x89, 0xc4, //0x0000031f movl         %eax, %r12d
+	0x45, 0x85, 0xdb, //0x00000322 testl        %r11d, %r11d
+	0x0f, 0x88, 0x1d, 0x02, 0x00, 0x00, //0x00000325 js           LBB0_38
+	0x4b, 0x8d, 0x34, 0x20, //0x0000032b leaq         (%r8,%r12), %rsi
+	0x41, 0x81, 0xfd, 0x10, 0x27, 0x00, 0x00, //0x0000032f cmpl         $10000, %r13d
+	0x0f, 0x82, 0xa7, 0x02, 0x00, 0x00, //0x00000336 jb           LBB0_43
+	0x44, 0x89, 0xe8, //0x0000033c movl         %r13d, %eax
+	0xb9, 0x59, 0x17, 0xb7, 0xd1, //0x0000033f movl         $3518437209, %ecx
+	0x48, 0x0f, 0xaf, 0xc8, //0x00000344 imulq        %rax, %rcx
+	0x48, 0xc1, 0xe9, 0x2d, //0x00000348 shrq         $45, %rcx
+	0x69, 0xc1, 0xf0, 0xd8, 0xff, 0xff, //0x0000034c imull        $-10000, %ecx, %eax
+	0x44, 0x01, 0xe8, //0x00000352 addl         %r13d, %eax
+	0x48, 0x69, 0xd0, 0x1f, 0x85, 0xeb, 0x51, //0x00000355 imulq        $1374389535, %rax, %rdx
+	0x48, 0xc1, 0xea, 0x25, //0x0000035c shrq         $37, %rdx
+	0x6b, 0xda, 0x64, //0x00000360 imull        $100, %edx, %ebx
+	0x29, 0xd8, //0x00000363 subl         %ebx, %eax
+	0x48, 0x8d, 0x1d, 0xf4, 0x09, 0x00, 0x00, //0x00000365 leaq         $2548(%rip), %rbx  /* _Digits+0(%rip) */
+	0x0f, 0xb7, 0x04, 0x43, //0x0000036c movzwl       (%rbx,%rax,2), %eax
+	0x66, 0x89, 0x46, 0xfe, //0x00000370 movw         %ax, $-2(%rsi)
+	0x48, 0x8d, 0x46, 0xfc, //0x00000374 leaq         $-4(%rsi), %rax
+	0x0f, 0xb7, 0x14, 0x53, //0x00000378 movzwl       (%rbx,%rdx,2), %edx
+	0x66, 0x89, 0x56, 0xfc, //0x0000037c movw         %dx, $-4(%rsi)
+	0x41, 0x89, 0xcd, //0x00000380 movl         %ecx, %r13d
+	0x41, 0x83, 0xfd, 0x64, //0x00000383 cmpl         $100, %r13d
+	0x0f, 0x83, 0x63, 0x02, 0x00, 0x00, //0x00000387 jae          LBB0_44
+	//0x0000038d LBB0_29
+	0x44, 0x89, 0xe9, //0x0000038d movl         %r13d, %ecx
+	0xe9, 0x9e, 0x02, 0x00, 0x00, //0x00000390 jmp          LBB0_46
+	//0x00000395 LBB0_30
+	0x45, 0x31, 0xc9, //0x00000395 xorl         %r9d, %r9d
+	0x48, 0x89, 0xd9, //0x00000398 movq         %rbx, %rcx
+	0x45, 0x89, 0xeb, //0x0000039b movl         %r13d, %r11d
+	0x41, 0x83, 0xfb, 0x64, //0x0000039e cmpl         $100, %r11d
+	0x0f, 0x82, 0x6f, 0xff, 0xff, 0xff, //0x000003a2 jb           LBB0_31
+	//0x000003a8 LBB0_64
+	0x48, 0xff, 0xc9, //0x000003a8 decq         %rcx
+	0x4c, 0x8d, 0x15, 0xae, 0x09, 0x00, 0x00, //0x000003ab leaq         $2478(%rip), %r10  /* _Digits+0(%rip) */
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000003b2 .p2align 4, 0x90
+	//0x000003c0 LBB0_65
+	0x44, 0x89, 0xda, //0x000003c0 movl         %r11d, %edx
+	0x48, 0x69, 0xd2, 0x1f, 0x85, 0xeb, 0x51, //0x000003c3 imulq        $1374389535, %rdx, %rdx
+	0x48, 0xc1, 0xea, 0x25, //0x000003ca shrq         $37, %rdx
+	0x6b, 0xc2, 0x64, //0x000003ce imull        $100, %edx, %eax
+	0x44, 0x89, 0xde, //0x000003d1 movl         %r11d, %esi
+	0x29, 0xc6, //0x000003d4 subl         %eax, %esi
+	0x41, 0x0f, 0xb7, 0x04, 0x72, //0x000003d6 movzwl       (%r10,%rsi,2), %eax
+	0x66, 0x89, 0x41, 0xff, //0x000003db movw         %ax, $-1(%rcx)
+	0x48, 0x83, 0xc1, 0xfe, //0x000003df addq         $-2, %rcx
+	0x41, 0x81, 0xfb, 0x0f, 0x27, 0x00, 0x00, //0x000003e3 cmpl         $9999, %r11d
+	0x41, 0x89, 0xd3, //0x000003ea movl         %edx, %r11d
+	0x0f, 0x87, 0xcd, 0xff, 0xff, 0xff, //0x000003ed ja           LBB0_65
+	//0x000003f3 LBB0_66
+	0x49, 0x8d, 0x70, 0x01, //0x000003f3 leaq         $1(%r8), %rsi
+	0x83, 0xfa, 0x0a, //0x000003f7 cmpl         $10, %edx
+	0x0f, 0x82, 0x1d, 0x00, 0x00, 0x00, //0x000003fa jb           LBB0_68
+	0x89, 0xd0, //0x00000400 movl         %edx, %eax
+	0x48, 0x8d, 0x0d, 0x57, 0x09, 0x00, 0x00, //0x00000402 leaq         $2391(%rip), %rcx  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x41, //0x00000409 movb         (%rcx,%rax,2), %dl
+	0x8a, 0x44, 0x41, 0x01, //0x0000040c movb         $1(%rcx,%rax,2), %al
+	0x41, 0x88, 0x50, 0x01, //0x00000410 movb         %dl, $1(%r8)
+	0x41, 0x88, 0x40, 0x02, //0x00000414 movb         %al, $2(%r8)
+	0xe9, 0x05, 0x00, 0x00, 0x00, //0x00000418 jmp          LBB0_69
+	//0x0000041d LBB0_68
+	0x80, 0xc2, 0x30, //0x0000041d addb         $48, %dl
+	0x88, 0x16, //0x00000420 movb         %dl, (%rsi)
+	//0x00000422 LBB0_69
+	0x4c, 0x29, 0xcb, //0x00000422 subq         %r9, %rbx
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000425 .p2align 4, 0x90
+	//0x00000430 LBB0_70
+	0x80, 0x7b, 0xff, 0x30, //0x00000430 cmpb         $48, $-1(%rbx)
+	0x48, 0x8d, 0x5b, 0xff, //0x00000434 leaq         $-1(%rbx), %rbx
+	0x0f, 0x84, 0xf2, 0xff, 0xff, 0xff, //0x00000438 je           LBB0_70
+	0x41, 0x88, 0x10, //0x0000043e movb         %dl, (%r8)
+	0x48, 0x8d, 0x43, 0x01, //0x00000441 leaq         $1(%rbx), %rax
+	0x48, 0x89, 0xc1, //0x00000445 movq         %rax, %rcx
+	0x48, 0x29, 0xf1, //0x00000448 subq         %rsi, %rcx
+	0x48, 0x83, 0xf9, 0x02, //0x0000044b cmpq         $2, %rcx
+	0x0f, 0x8c, 0x06, 0x00, 0x00, 0x00, //0x0000044f jl           LBB0_73
+	0xc6, 0x06, 0x2e, //0x00000455 movb         $46, (%rsi)
+	0x48, 0x89, 0xc3, //0x00000458 movq         %rax, %rbx
+	//0x0000045b LBB0_73
+	0xc6, 0x03, 0x65, //0x0000045b movb         $101, (%rbx)
+	0x45, 0x85, 0xff, //0x0000045e testl        %r15d, %r15d
+	0x0f, 0x8e, 0x41, 0x01, 0x00, 0x00, //0x00000461 jle          LBB0_76
+	0x41, 0xff, 0xcf, //0x00000467 decl         %r15d
+	0xc6, 0x43, 0x01, 0x2b, //0x0000046a movb         $43, $1(%rbx)
+	0x44, 0x89, 0xf8, //0x0000046e movl         %r15d, %eax
+	0x83, 0xf8, 0x64, //0x00000471 cmpl         $100, %eax
+	0x0f, 0x8c, 0x43, 0x01, 0x00, 0x00, //0x00000474 jl           LBB0_77
+	//0x0000047a LBB0_75
+	0x89, 0xc1, //0x0000047a movl         %eax, %ecx
+	0xba, 0xcd, 0xcc, 0xcc, 0xcc, //0x0000047c movl         $3435973837, %edx
+	0x48, 0x0f, 0xaf, 0xd1, //0x00000481 imulq        %rcx, %rdx
+	0x48, 0xc1, 0xea, 0x23, //0x00000485 shrq         $35, %rdx
+	0x8d, 0x0c, 0x12, //0x00000489 leal         (%rdx,%rdx), %ecx
+	0x8d, 0x0c, 0x89, //0x0000048c leal         (%rcx,%rcx,4), %ecx
+	0x29, 0xc8, //0x0000048f subl         %ecx, %eax
+	0x48, 0x8d, 0x0d, 0xc8, 0x08, 0x00, 0x00, //0x00000491 leaq         $2248(%rip), %rcx  /* _Digits+0(%rip) */
+	0x0f, 0xb7, 0x0c, 0x51, //0x00000498 movzwl       (%rcx,%rdx,2), %ecx
+	0x66, 0x89, 0x4b, 0x02, //0x0000049c movw         %cx, $2(%rbx)
+	0x0c, 0x30, //0x000004a0 orb          $48, %al
+	0x88, 0x43, 0x04, //0x000004a2 movb         %al, $4(%rbx)
+	0x48, 0x83, 0xc3, 0x05, //0x000004a5 addq         $5, %rbx
+	0x49, 0x89, 0xd8, //0x000004a9 movq         %rbx, %r8
+	0xe9, 0x7f, 0x08, 0x00, 0x00, //0x000004ac jmp          LBB0_137
+	//0x000004b1 LBB0_32
+	0xd3, 0xee, //0x000004b1 shrl         %cl, %esi
+	0x81, 0xfe, 0xa0, 0x86, 0x01, 0x00, //0x000004b3 cmpl         $100000, %esi
+	0x0f, 0x82, 0x1a, 0x02, 0x00, 0x00, //0x000004b9 jb           LBB0_52
+	0xb8, 0x06, 0x00, 0x00, 0x00, //0x000004bf movl         $6, %eax
+	0x81, 0xfe, 0x40, 0x42, 0x0f, 0x00, //0x000004c4 cmpl         $1000000, %esi
+	0x0f, 0x82, 0x20, 0x00, 0x00, 0x00, //0x000004ca jb           LBB0_36
+	0xb8, 0x07, 0x00, 0x00, 0x00, //0x000004d0 movl         $7, %eax
+	0x81, 0xfe, 0x80, 0x96, 0x98, 0x00, //0x000004d5 cmpl         $10000000, %esi
+	0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x000004db jb           LBB0_36
+	0x81, 0xfe, 0x00, 0xe1, 0xf5, 0x05, //0x000004e1 cmpl         $100000000, %esi
+	0xb8, 0x09, 0x00, 0x00, 0x00, //0x000004e7 movl         $9, %eax
+	0x48, 0x83, 0xd8, 0x00, //0x000004ec sbbq         $0, %rax
+	//0x000004f0 LBB0_36
+	0x4c, 0x01, 0xc0, //0x000004f0 addq         %r8, %rax
+	//0x000004f3 LBB0_37
+	0x89, 0xf1, //0x000004f3 movl         %esi, %ecx
+	0xba, 0x59, 0x17, 0xb7, 0xd1, //0x000004f5 movl         $3518437209, %edx
+	0x48, 0x0f, 0xaf, 0xd1, //0x000004fa imulq        %rcx, %rdx
+	0x48, 0xc1, 0xea, 0x2d, //0x000004fe shrq         $45, %rdx
+	0x69, 0xca, 0xf0, 0xd8, 0xff, 0xff, //0x00000502 imull        $-10000, %edx, %ecx
+	0x01, 0xf1, //0x00000508 addl         %esi, %ecx
+	0x48, 0x69, 0xf1, 0x1f, 0x85, 0xeb, 0x51, //0x0000050a imulq        $1374389535, %rcx, %rsi
+	0x48, 0xc1, 0xee, 0x25, //0x00000511 shrq         $37, %rsi
+	0x6b, 0xde, 0x64, //0x00000515 imull        $100, %esi, %ebx
+	0x29, 0xd9, //0x00000518 subl         %ebx, %ecx
+	0x48, 0x8d, 0x1d, 0x3f, 0x08, 0x00, 0x00, //0x0000051a leaq         $2111(%rip), %rbx  /* _Digits+0(%rip) */
+	0x0f, 0xb7, 0x0c, 0x4b, //0x00000521 movzwl       (%rbx,%rcx,2), %ecx
+	0x66, 0x89, 0x48, 0xfe, //0x00000525 movw         %cx, $-2(%rax)
+	0x0f, 0xb7, 0x0c, 0x73, //0x00000529 movzwl       (%rbx,%rsi,2), %ecx
+	0x66, 0x89, 0x48, 0xfc, //0x0000052d movw         %cx, $-4(%rax)
+	0x49, 0x89, 0xc1, //0x00000531 movq         %rax, %r9
+	0x48, 0x83, 0xc0, 0xfc, //0x00000534 addq         $-4, %rax
+	0x89, 0xd6, //0x00000538 movl         %edx, %esi
+	0x83, 0xfe, 0x64, //0x0000053a cmpl         $100, %esi
+	0x0f, 0x83, 0xd5, 0x01, 0x00, 0x00, //0x0000053d jae          LBB0_56
+	0xe9, 0x17, 0x02, 0x00, 0x00, //0x00000543 jmp          LBB0_58
+	//0x00000548 LBB0_38
+	0x45, 0x85, 0xff, //0x00000548 testl        %r15d, %r15d
+	0x0f, 0x8f, 0x90, 0x04, 0x00, 0x00, //0x0000054b jg           LBB0_98
+	0x66, 0x41, 0xc7, 0x00, 0x30, 0x2e, //0x00000551 movw         $11824, (%r8)
+	0x49, 0x83, 0xc0, 0x02, //0x00000557 addq         $2, %r8
+	0x45, 0x85, 0xff, //0x0000055b testl        %r15d, %r15d
+	0x0f, 0x89, 0x7d, 0x04, 0x00, 0x00, //0x0000055e jns          LBB0_98
+	0x31, 0xf6, //0x00000564 xorl         %esi, %esi
+	0x41, 0x83, 0xff, 0x80, //0x00000566 cmpl         $-128, %r15d
+	0x0f, 0x87, 0x5a, 0x04, 0x00, 0x00, //0x0000056a ja           LBB0_96
+	0x45, 0x89, 0xfa, //0x00000570 movl         %r15d, %r10d
+	0x41, 0xf7, 0xd2, //0x00000573 notl         %r10d
+	0x49, 0xff, 0xc2, //0x00000576 incq         %r10
+	0x4c, 0x89, 0xd6, //0x00000579 movq         %r10, %rsi
+	0x48, 0x83, 0xe6, 0x80, //0x0000057c andq         $-128, %rsi
+	0x48, 0x8d, 0x46, 0x80, //0x00000580 leaq         $-128(%rsi), %rax
+	0x48, 0x89, 0xc1, //0x00000584 movq         %rax, %rcx
+	0x48, 0xc1, 0xe9, 0x07, //0x00000587 shrq         $7, %rcx
+	0x48, 0xff, 0xc1, //0x0000058b incq         %rcx
+	0x41, 0x89, 0xcb, //0x0000058e movl         %ecx, %r11d
+	0x41, 0x83, 0xe3, 0x03, //0x00000591 andl         $3, %r11d
+	0x48, 0x3d, 0x80, 0x01, 0x00, 0x00, //0x00000595 cmpq         $384, %rax
+	0x0f, 0x83, 0x38, 0x03, 0x00, 0x00, //0x0000059b jae          LBB0_90
+	0x31, 0xdb, //0x000005a1 xorl         %ebx, %ebx
+	0xe9, 0xda, 0x03, 0x00, 0x00, //0x000005a3 jmp          LBB0_92
+	//0x000005a8 LBB0_76
+	0xc6, 0x43, 0x01, 0x2d, //0x000005a8 movb         $45, $1(%rbx)
+	0xb8, 0x01, 0x00, 0x00, 0x00, //0x000005ac movl         $1, %eax
+	0x44, 0x29, 0xf8, //0x000005b1 subl         %r15d, %eax
+	0x83, 0xf8, 0x64, //0x000005b4 cmpl         $100, %eax
+	0x0f, 0x8d, 0xbd, 0xfe, 0xff, 0xff, //0x000005b7 jge          LBB0_75
+	//0x000005bd LBB0_77
+	0x83, 0xf8, 0x0a, //0x000005bd cmpl         $10, %eax
+	0x0f, 0x8c, 0x02, 0x01, 0x00, 0x00, //0x000005c0 jl           LBB0_79
+	0x48, 0x98, //0x000005c6 cltq         
+	0x48, 0x8d, 0x0d, 0x91, 0x07, 0x00, 0x00, //0x000005c8 leaq         $1937(%rip), %rcx  /* _Digits+0(%rip) */
+	0x0f, 0xb7, 0x04, 0x41, //0x000005cf movzwl       (%rcx,%rax,2), %eax
+	0x66, 0x89, 0x43, 0x02, //0x000005d3 movw         %ax, $2(%rbx)
+	0x48, 0x83, 0xc3, 0x04, //0x000005d7 addq         $4, %rbx
+	0x49, 0x89, 0xd8, //0x000005db movq         %rbx, %r8
+	0xe9, 0x4d, 0x07, 0x00, 0x00, //0x000005de jmp          LBB0_137
+	//0x000005e3 LBB0_43
+	0x48, 0x89, 0xf0, //0x000005e3 movq         %rsi, %rax
+	0x41, 0x83, 0xfd, 0x64, //0x000005e6 cmpl         $100, %r13d
+	0x0f, 0x82, 0x9d, 0xfd, 0xff, 0xff, //0x000005ea jb           LBB0_29
+	//0x000005f0 LBB0_44
+	0x48, 0xff, 0xc8, //0x000005f0 decq         %rax
+	0x4c, 0x8d, 0x15, 0x66, 0x07, 0x00, 0x00, //0x000005f3 leaq         $1894(%rip), %r10  /* _Digits+0(%rip) */
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000005fa .p2align 4, 0x90
+	//0x00000600 LBB0_45
+	0x44, 0x89, 0xe9, //0x00000600 movl         %r13d, %ecx
+	0x48, 0x69, 0xc9, 0x1f, 0x85, 0xeb, 0x51, //0x00000603 imulq        $1374389535, %rcx, %rcx
+	0x48, 0xc1, 0xe9, 0x25, //0x0000060a shrq         $37, %rcx
+	0x6b, 0xd9, 0x64, //0x0000060e imull        $100, %ecx, %ebx
+	0x44, 0x89, 0xea, //0x00000611 movl         %r13d, %edx
+	0x29, 0xda, //0x00000614 subl         %ebx, %edx
+	0x41, 0x0f, 0xb7, 0x14, 0x52, //0x00000616 movzwl       (%r10,%rdx,2), %edx
+	0x66, 0x89, 0x50, 0xff, //0x0000061b movw         %dx, $-1(%rax)
+	0x48, 0x83, 0xc0, 0xfe, //0x0000061f addq         $-2, %rax
+	0x41, 0x81, 0xfd, 0x0f, 0x27, 0x00, 0x00, //0x00000623 cmpl         $9999, %r13d
+	0x41, 0x89, 0xcd, //0x0000062a movl         %ecx, %r13d
+	0x0f, 0x87, 0xcd, 0xff, 0xff, 0xff, //0x0000062d ja           LBB0_45
+	//0x00000633 LBB0_46
+	0x49, 0x63, 0xc7, //0x00000633 movslq       %r15d, %rax
+	0x83, 0xf9, 0x0a, //0x00000636 cmpl         $10, %ecx
+	0x0f, 0x82, 0x22, 0x00, 0x00, 0x00, //0x00000639 jb           LBB0_48
+	0x89, 0xc9, //0x0000063f movl         %ecx, %ecx
+	0x48, 0x8d, 0x15, 0x18, 0x07, 0x00, 0x00, //0x00000641 leaq         $1816(%rip), %rdx  /* _Digits+0(%rip) */
+	0x0f, 0xb7, 0x0c, 0x4a, //0x00000648 movzwl       (%rdx,%rcx,2), %ecx
+	0x66, 0x41, 0x89, 0x08, //0x0000064c movw         %cx, (%r8)
+	0x49, 0x01, 0xc0, //0x00000650 addq         %rax, %r8
+	0x49, 0x39, 0xc4, //0x00000653 cmpq         %rax, %r12
+	0x0f, 0x8c, 0x17, 0x00, 0x00, 0x00, //0x00000656 jl           LBB0_49
+	0xe9, 0xcf, 0x06, 0x00, 0x00, //0x0000065c jmp          LBB0_137
+	//0x00000661 LBB0_48
+	0x80, 0xc1, 0x30, //0x00000661 addb         $48, %cl
+	0x41, 0x88, 0x08, //0x00000664 movb         %cl, (%r8)
+	0x49, 0x01, 0xc0, //0x00000667 addq         %rax, %r8
+	0x49, 0x39, 0xc4, //0x0000066a cmpq         %rax, %r12
+	0x0f, 0x8d, 0xbd, 0x06, 0x00, 0x00, //0x0000066d jge          LBB0_137
+	//0x00000673 LBB0_49
+	0x4b, 0x8d, 0x04, 0x21, //0x00000673 leaq         (%r9,%r12), %rax
+	0x4c, 0x8d, 0x5c, 0x07, 0x01, //0x00000677 leaq         $1(%rdi,%rax), %r11
+	0x4d, 0x39, 0xc3, //0x0000067c cmpq         %r8, %r11
+	0x4d, 0x0f, 0x46, 0xd8, //0x0000067f cmovbeq      %r8, %r11
+	0x4a, 0x8d, 0x0c, 0x0f, //0x00000683 leaq         (%rdi,%r9), %rcx
+	0x4c, 0x01, 0xe1, //0x00000687 addq         %r12, %rcx
+	0x49, 0x29, 0xcb, //0x0000068a subq         %rcx, %r11
+	0x49, 0x81, 0xfb, 0x80, 0x00, 0x00, 0x00, //0x0000068d cmpq         $128, %r11
+	0x0f, 0x82, 0x06, 0x02, 0x00, 0x00, //0x00000694 jb           LBB0_87
+	0x4d, 0x89, 0xda, //0x0000069a movq         %r11, %r10
+	0x49, 0x83, 0xe2, 0x80, //0x0000069d andq         $-128, %r10
+	0x49, 0x8d, 0x4a, 0x80, //0x000006a1 leaq         $-128(%r10), %rcx
+	0x48, 0x89, 0xcb, //0x000006a5 movq         %rcx, %rbx
+	0x48, 0xc1, 0xeb, 0x07, //0x000006a8 shrq         $7, %rbx
+	0x48, 0xff, 0xc3, //0x000006ac incq         %rbx
+	0x89, 0xda, //0x000006af movl         %ebx, %edx
+	0x83, 0xe2, 0x03, //0x000006b1 andl         $3, %edx
+	0x48, 0x81, 0xf9, 0x80, 0x01, 0x00, 0x00, //0x000006b4 cmpq         $384, %rcx
+	0x0f, 0x83, 0xe8, 0x00, 0x00, 0x00, //0x000006bb jae          LBB0_80
+	0x31, 0xc0, //0x000006c1 xorl         %eax, %eax
+	0xe9, 0x88, 0x01, 0x00, 0x00, //0x000006c3 jmp          LBB0_82
+	//0x000006c8 LBB0_79
+	0x04, 0x30, //0x000006c8 addb         $48, %al
+	0x88, 0x43, 0x02, //0x000006ca movb         %al, $2(%rbx)
+	0x48, 0x83, 0xc3, 0x03, //0x000006cd addq         $3, %rbx
+	0x49, 0x89, 0xd8, //0x000006d1 movq         %rbx, %r8
+	0xe9, 0x57, 0x06, 0x00, 0x00, //0x000006d4 jmp          LBB0_137
+	//0x000006d9 LBB0_52
+	0x41, 0xb9, 0x01, 0x00, 0x00, 0x00, //0x000006d9 movl         $1, %r9d
+	0x83, 0xfe, 0x0a, //0x000006df cmpl         $10, %esi
+	0x0f, 0x82, 0x21, 0x00, 0x00, 0x00, //0x000006e2 jb           LBB0_55
+	0x41, 0xb9, 0x02, 0x00, 0x00, 0x00, //0x000006e8 movl         $2, %r9d
+	0x83, 0xfe, 0x64, //0x000006ee cmpl         $100, %esi
+	0x0f, 0x82, 0x12, 0x00, 0x00, 0x00, //0x000006f1 jb           LBB0_55
+	0x41, 0xb9, 0x03, 0x00, 0x00, 0x00, //0x000006f7 movl         $3, %r9d
+	0x81, 0xfe, 0xe8, 0x03, 0x00, 0x00, //0x000006fd cmpl         $1000, %esi
+	0x0f, 0x83, 0xab, 0x01, 0x00, 0x00, //0x00000703 jae          LBB0_88
+	//0x00000709 LBB0_55
+	0x4d, 0x01, 0xc1, //0x00000709 addq         %r8, %r9
+	0x4c, 0x89, 0xc8, //0x0000070c movq         %r9, %rax
+	0x83, 0xfe, 0x64, //0x0000070f cmpl         $100, %esi
+	0x0f, 0x82, 0x47, 0x00, 0x00, 0x00, //0x00000712 jb           LBB0_58
+	//0x00000718 LBB0_56
+	0x48, 0xff, 0xc8, //0x00000718 decq         %rax
+	0x4c, 0x8d, 0x15, 0x3e, 0x06, 0x00, 0x00, //0x0000071b leaq         $1598(%rip), %r10  /* _Digits+0(%rip) */
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000722 .p2align 4, 0x90
+	//0x00000730 LBB0_57
+	0x89, 0xf3, //0x00000730 movl         %esi, %ebx
+	0x89, 0xf6, //0x00000732 movl         %esi, %esi
+	0x48, 0x69, 0xf6, 0x1f, 0x85, 0xeb, 0x51, //0x00000734 imulq        $1374389535, %rsi, %rsi
+	0x48, 0xc1, 0xee, 0x25, //0x0000073b shrq         $37, %rsi
+	0x6b, 0xce, 0x64, //0x0000073f imull        $100, %esi, %ecx
+	0x89, 0xda, //0x00000742 movl         %ebx, %edx
+	0x29, 0xca, //0x00000744 subl         %ecx, %edx
+	0x41, 0x0f, 0xb7, 0x0c, 0x52, //0x00000746 movzwl       (%r10,%rdx,2), %ecx
+	0x66, 0x89, 0x48, 0xff, //0x0000074b movw         %cx, $-1(%rax)
+	0x48, 0x83, 0xc0, 0xfe, //0x0000074f addq         $-2, %rax
+	0x81, 0xfb, 0x0f, 0x27, 0x00, 0x00, //0x00000753 cmpl         $9999, %ebx
+	0x0f, 0x87, 0xd1, 0xff, 0xff, 0xff, //0x00000759 ja           LBB0_57
+	//0x0000075f LBB0_58
+	0x83, 0xfe, 0x0a, //0x0000075f cmpl         $10, %esi
+	0x0f, 0x82, 0x16, 0x00, 0x00, 0x00, //0x00000762 jb           LBB0_60
+	0x89, 0xf0, //0x00000768 movl         %esi, %eax
+	0x48, 0x8d, 0x0d, 0xef, 0x05, 0x00, 0x00, //0x0000076a leaq         $1519(%rip), %rcx  /* _Digits+0(%rip) */
+	0x0f, 0xb7, 0x04, 0x41, //0x00000771 movzwl       (%rcx,%rax,2), %eax
+	0x66, 0x41, 0x89, 0x00, //0x00000775 movw         %ax, (%r8)
+	0xe9, 0x07, 0x00, 0x00, 0x00, //0x00000779 jmp          LBB0_61
+	//0x0000077e LBB0_60
+	0x40, 0x80, 0xc6, 0x30, //0x0000077e addb         $48, %sil
+	0x41, 0x88, 0x30, //0x00000782 movb         %sil, (%r8)
+	//0x00000785 LBB0_61
+	0x41, 0x29, 0xf9, //0x00000785 subl         %edi, %r9d
+	0x45, 0x89, 0xc8, //0x00000788 movl         %r9d, %r8d
+	0xe9, 0xa3, 0x05, 0x00, 0x00, //0x0000078b jmp          LBB0_138
+	//0x00000790 LBB0_62
+	0x41, 0xb9, 0x04, 0x00, 0x00, 0x00, //0x00000790 movl         $4, %r9d
+	0x48, 0x8d, 0x4b, 0xfc, //0x00000796 leaq         $-4(%rbx), %rcx
+	0x41, 0x83, 0xfb, 0x64, //0x0000079a cmpl         $100, %r11d
+	0x0f, 0x82, 0x73, 0xfb, 0xff, 0xff, //0x0000079e jb           LBB0_31
+	0xe9, 0xff, 0xfb, 0xff, 0xff, //0x000007a4 jmp          LBB0_64
+	//0x000007a9 LBB0_80
+	0x48, 0x29, 0xd3, //0x000007a9 subq         %rdx, %rbx
+	0x48, 0x8d, 0x8c, 0x07, 0xe0, 0x01, 0x00, 0x00, //0x000007ac leaq         $480(%rdi,%rax), %rcx
+	0x31, 0xc0, //0x000007b4 xorl         %eax, %eax
+	0xc5, 0xfe, 0x6f, 0x05, 0x42, 0xf8, 0xff, 0xff, //0x000007b6 vmovdqu      $-1982(%rip), %ymm0  /* LCPI0_0+0(%rip) */
+	0x90, 0x90, //0x000007be .p2align 4, 0x90
+	//0x000007c0 LBB0_81
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0x20, 0xfe, 0xff, 0xff, //0x000007c0 vmovdqu      %ymm0, $-480(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0x40, 0xfe, 0xff, 0xff, //0x000007c9 vmovdqu      %ymm0, $-448(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0x60, 0xfe, 0xff, 0xff, //0x000007d2 vmovdqu      %ymm0, $-416(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0x80, 0xfe, 0xff, 0xff, //0x000007db vmovdqu      %ymm0, $-384(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0xa0, 0xfe, 0xff, 0xff, //0x000007e4 vmovdqu      %ymm0, $-352(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0xc0, 0xfe, 0xff, 0xff, //0x000007ed vmovdqu      %ymm0, $-320(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0xe0, 0xfe, 0xff, 0xff, //0x000007f6 vmovdqu      %ymm0, $-288(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0x00, 0xff, 0xff, 0xff, //0x000007ff vmovdqu      %ymm0, $-256(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0x20, 0xff, 0xff, 0xff, //0x00000808 vmovdqu      %ymm0, $-224(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0x40, 0xff, 0xff, 0xff, //0x00000811 vmovdqu      %ymm0, $-192(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x01, 0x60, 0xff, 0xff, 0xff, //0x0000081a vmovdqu      %ymm0, $-160(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x44, 0x01, 0x80, //0x00000823 vmovdqu      %ymm0, $-128(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x44, 0x01, 0xa0, //0x00000829 vmovdqu      %ymm0, $-96(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x44, 0x01, 0xc0, //0x0000082f vmovdqu      %ymm0, $-64(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x44, 0x01, 0xe0, //0x00000835 vmovdqu      %ymm0, $-32(%rcx,%rax)
+	0xc5, 0xfe, 0x7f, 0x04, 0x01, //0x0000083b vmovdqu      %ymm0, (%rcx,%rax)
+	0x48, 0x05, 0x00, 0x02, 0x00, 0x00, //0x00000840 addq         $512, %rax
+	0x48, 0x83, 0xc3, 0xfc, //0x00000846 addq         $-4, %rbx
+	0x0f, 0x85, 0x70, 0xff, 0xff, 0xff, //0x0000084a jne          LBB0_81
+	//0x00000850 LBB0_82
+	0x48, 0x85, 0xd2, //0x00000850 testq        %rdx, %rdx
+	0x0f, 0x84, 0x37, 0x00, 0x00, 0x00, //0x00000853 je           LBB0_85
+	0x4c, 0x01, 0xc8, //0x00000859 addq         %r9, %rax
+	0x4c, 0x01, 0xe0, //0x0000085c addq         %r12, %rax
+	0x48, 0x8d, 0x44, 0x07, 0x60, //0x0000085f leaq         $96(%rdi,%rax), %rax
+	0x48, 0xf7, 0xda, //0x00000864 negq         %rdx
+	0xc5, 0xfe, 0x6f, 0x05, 0x91, 0xf7, 0xff, 0xff, //0x00000867 vmovdqu      $-2159(%rip), %ymm0  /* LCPI0_0+0(%rip) */
+	0x90, //0x0000086f .p2align 4, 0x90
+	//0x00000870 LBB0_84
+	0xc5, 0xfe, 0x7f, 0x40, 0xa0, //0x00000870 vmovdqu      %ymm0, $-96(%rax)
+	0xc5, 0xfe, 0x7f, 0x40, 0xc0, //0x00000875 vmovdqu      %ymm0, $-64(%rax)
+	0xc5, 0xfe, 0x7f, 0x40, 0xe0, //0x0000087a vmovdqu      %ymm0, $-32(%rax)
+	0xc5, 0xfe, 0x7f, 0x00, //0x0000087f vmovdqu      %ymm0, (%rax)
+	0x48, 0x83, 0xe8, 0x80, //0x00000883 subq         $-128, %rax
+	0x48, 0xff, 0xc2, //0x00000887 incq         %rdx
+	0x0f, 0x85, 0xe0, 0xff, 0xff, 0xff, //0x0000088a jne          LBB0_84
+	//0x00000890 LBB0_85
+	0x4d, 0x39, 0xda, //0x00000890 cmpq         %r11, %r10
+	0x0f, 0x84, 0x97, 0x04, 0x00, 0x00, //0x00000893 je           LBB0_137
+	0x4c, 0x01, 0xd6, //0x00000899 addq         %r10, %rsi
+	0x90, 0x90, 0x90, 0x90, //0x0000089c .p2align 4, 0x90
+	//0x000008a0 LBB0_87
+	0xc6, 0x06, 0x30, //0x000008a0 movb         $48, (%rsi)
+	0x48, 0xff, 0xc6, //0x000008a3 incq         %rsi
+	0x4c, 0x39, 0xc6, //0x000008a6 cmpq         %r8, %rsi
+	0x0f, 0x82, 0xf1, 0xff, 0xff, 0xff, //0x000008a9 jb           LBB0_87
+	0xe9, 0x7c, 0x04, 0x00, 0x00, //0x000008af jmp          LBB0_137
+	//0x000008b4 LBB0_88
+	0x81, 0xfe, 0x10, 0x27, 0x00, 0x00, //0x000008b4 cmpl         $10000, %esi
+	0x4c, 0x89, 0xc0, //0x000008ba movq         %r8, %rax
+	0x48, 0x83, 0xd8, 0x00, //0x000008bd sbbq         $0, %rax
+	0x48, 0x83, 0xc0, 0x05, //0x000008c1 addq         $5, %rax
+	0x81, 0xfe, 0x10, 0x27, 0x00, 0x00, //0x000008c5 cmpl         $10000, %esi
+	0x0f, 0x83, 0x22, 0xfc, 0xff, 0xff, //0x000008cb jae          LBB0_37
+	0x49, 0x89, 0xc1, //0x000008d1 movq         %rax, %r9
+	0xe9, 0x3f, 0xfe, 0xff, 0xff, //0x000008d4 jmp          LBB0_56
+	//0x000008d9 LBB0_90
+	0x49, 0x8d, 0x84, 0x39, 0xe2, 0x01, 0x00, 0x00, //0x000008d9 leaq         $482(%r9,%rdi), %rax
+	0x4d, 0x89, 0xde, //0x000008e1 movq         %r11, %r14
+	0x49, 0x29, 0xce, //0x000008e4 subq         %rcx, %r14
+	0x31, 0xdb, //0x000008e7 xorl         %ebx, %ebx
+	0xc5, 0xfe, 0x6f, 0x05, 0x0f, 0xf7, 0xff, 0xff, //0x000008e9 vmovdqu      $-2289(%rip), %ymm0  /* LCPI0_0+0(%rip) */
+	//0x000008f1 LBB0_91
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0x20, 0xfe, 0xff, 0xff, //0x000008f1 vmovdqu      %ymm0, $-480(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0x40, 0xfe, 0xff, 0xff, //0x000008fa vmovdqu      %ymm0, $-448(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0x60, 0xfe, 0xff, 0xff, //0x00000903 vmovdqu      %ymm0, $-416(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0x80, 0xfe, 0xff, 0xff, //0x0000090c vmovdqu      %ymm0, $-384(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0xa0, 0xfe, 0xff, 0xff, //0x00000915 vmovdqu      %ymm0, $-352(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0xc0, 0xfe, 0xff, 0xff, //0x0000091e vmovdqu      %ymm0, $-320(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0xe0, 0xfe, 0xff, 0xff, //0x00000927 vmovdqu      %ymm0, $-288(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0x00, 0xff, 0xff, 0xff, //0x00000930 vmovdqu      %ymm0, $-256(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0x20, 0xff, 0xff, 0xff, //0x00000939 vmovdqu      %ymm0, $-224(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0x40, 0xff, 0xff, 0xff, //0x00000942 vmovdqu      %ymm0, $-192(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x84, 0x18, 0x60, 0xff, 0xff, 0xff, //0x0000094b vmovdqu      %ymm0, $-160(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x44, 0x18, 0x80, //0x00000954 vmovdqu      %ymm0, $-128(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x44, 0x18, 0xa0, //0x0000095a vmovdqu      %ymm0, $-96(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x44, 0x18, 0xc0, //0x00000960 vmovdqu      %ymm0, $-64(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x44, 0x18, 0xe0, //0x00000966 vmovdqu      %ymm0, $-32(%rax,%rbx)
+	0xc5, 0xfe, 0x7f, 0x04, 0x18, //0x0000096c vmovdqu      %ymm0, (%rax,%rbx)
+	0x48, 0x81, 0xc3, 0x00, 0x02, 0x00, 0x00, //0x00000971 addq         $512, %rbx
+	0x49, 0x83, 0xc6, 0x04, //0x00000978 addq         $4, %r14
+	0x0f, 0x85, 0x6f, 0xff, 0xff, 0xff, //0x0000097c jne          LBB0_91
+	//0x00000982 LBB0_92
+	0x4d, 0x85, 0xdb, //0x00000982 testq        %r11, %r11
+	0x0f, 0x84, 0x33, 0x00, 0x00, 0x00, //0x00000985 je           LBB0_95
+	0x4c, 0x01, 0xcb, //0x0000098b addq         %r9, %rbx
+	0x48, 0x8d, 0x44, 0x1f, 0x62, //0x0000098e leaq         $98(%rdi,%rbx), %rax
+	0x49, 0xf7, 0xdb, //0x00000993 negq         %r11
+	0xc5, 0xfe, 0x6f, 0x05, 0x62, 0xf6, 0xff, 0xff, //0x00000996 vmovdqu      $-2462(%rip), %ymm0  /* LCPI0_0+0(%rip) */
+	//0x0000099e LBB0_94
+	0xc5, 0xfe, 0x7f, 0x40, 0xa0, //0x0000099e vmovdqu      %ymm0, $-96(%rax)
+	0xc5, 0xfe, 0x7f, 0x40, 0xc0, //0x000009a3 vmovdqu      %ymm0, $-64(%rax)
+	0xc5, 0xfe, 0x7f, 0x40, 0xe0, //0x000009a8 vmovdqu      %ymm0, $-32(%rax)
+	0xc5, 0xfe, 0x7f, 0x00, //0x000009ad vmovdqu      %ymm0, (%rax)
+	0x48, 0x83, 0xe8, 0x80, //0x000009b1 subq         $-128, %rax
+	0x49, 0xff, 0xc3, //0x000009b5 incq         %r11
+	0x0f, 0x85, 0xe0, 0xff, 0xff, 0xff, //0x000009b8 jne          LBB0_94
+	//0x000009be LBB0_95
+	0x49, 0x01, 0xf0, //0x000009be addq         %rsi, %r8
+	0x49, 0x39, 0xf2, //0x000009c1 cmpq         %rsi, %r10
+	0x0f, 0x84, 0x17, 0x00, 0x00, 0x00, //0x000009c4 je           LBB0_98
+	//0x000009ca LBB0_96
+	0x44, 0x89, 0xf8, //0x000009ca movl         %r15d, %eax
+	0xf7, 0xd8, //0x000009cd negl         %eax
+	0x90, //0x000009cf .p2align 4, 0x90
+	//0x000009d0 LBB0_97
+	0x41, 0xc6, 0x00, 0x30, //0x000009d0 movb         $48, (%r8)
+	0x49, 0xff, 0xc0, //0x000009d4 incq         %r8
+	0xff, 0xc6, //0x000009d7 incl         %esi
+	0x39, 0xc6, //0x000009d9 cmpl         %eax, %esi
+	0x0f, 0x8c, 0xef, 0xff, 0xff, 0xff, //0x000009db jl           LBB0_97
+	//0x000009e1 LBB0_98
+	0x4b, 0x8d, 0x04, 0x20, //0x000009e1 leaq         (%r8,%r12), %rax
+	0x41, 0x81, 0xfd, 0x10, 0x27, 0x00, 0x00, //0x000009e5 cmpl         $10000, %r13d
+	0x0f, 0x82, 0x63, 0x00, 0x00, 0x00, //0x000009ec jb           LBB0_101
+	0x44, 0x89, 0xe9, //0x000009f2 movl         %r13d, %ecx
+	0x41, 0xba, 0x59, 0x17, 0xb7, 0xd1, //0x000009f5 movl         $3518437209, %r10d
+	0x4c, 0x0f, 0xaf, 0xd1, //0x000009fb imulq        %rcx, %r10
+	0x49, 0xc1, 0xea, 0x2d, //0x000009ff shrq         $45, %r10
+	0x41, 0x69, 0xca, 0xf0, 0xd8, 0xff, 0xff, //0x00000a03 imull        $-10000, %r10d, %ecx
+	0x44, 0x01, 0xe9, //0x00000a0a addl         %r13d, %ecx
+	0x0f, 0x84, 0x87, 0x01, 0x00, 0x00, //0x00000a0d je           LBB0_103
+	0x89, 0xca, //0x00000a13 movl         %ecx, %edx
+	0x48, 0x69, 0xd2, 0x1f, 0x85, 0xeb, 0x51, //0x00000a15 imulq        $1374389535, %rdx, %rdx
+	0x48, 0xc1, 0xea, 0x25, //0x00000a1c shrq         $37, %rdx
+	0x6b, 0xda, 0x64, //0x00000a20 imull        $100, %edx, %ebx
+	0x29, 0xd9, //0x00000a23 subl         %ebx, %ecx
+	0x48, 0x8d, 0x1d, 0x34, 0x03, 0x00, 0x00, //0x00000a25 leaq         $820(%rip), %rbx  /* _Digits+0(%rip) */
+	0x0f, 0xb7, 0x0c, 0x4b, //0x00000a2c movzwl       (%rbx,%rcx,2), %ecx
+	0x66, 0x89, 0x48, 0xfe, //0x00000a30 movw         %cx, $-2(%rax)
+	0x0f, 0xb7, 0x0c, 0x53, //0x00000a34 movzwl       (%rbx,%rdx,2), %ecx
+	0x66, 0x89, 0x48, 0xfc, //0x00000a38 movw         %cx, $-4(%rax)
+	0x45, 0x31, 0xc9, //0x00000a3c xorl         %r9d, %r9d
+	0x48, 0x83, 0xc0, 0xfc, //0x00000a3f addq         $-4, %rax
+	0x41, 0x83, 0xfa, 0x64, //0x00000a43 cmpl         $100, %r10d
+	0x0f, 0x83, 0x18, 0x00, 0x00, 0x00, //0x00000a47 jae          LBB0_105
+	//0x00000a4d LBB0_102
+	0x44, 0x89, 0xd1, //0x00000a4d movl         %r10d, %ecx
+	0xe9, 0x4d, 0x00, 0x00, 0x00, //0x00000a50 jmp          LBB0_107
+	//0x00000a55 LBB0_101
+	0x45, 0x31, 0xc9, //0x00000a55 xorl         %r9d, %r9d
+	0x45, 0x89, 0xea, //0x00000a58 movl         %r13d, %r10d
+	0x41, 0x83, 0xfa, 0x64, //0x00000a5b cmpl         $100, %r10d
+	0x0f, 0x82, 0xe8, 0xff, 0xff, 0xff, //0x00000a5f jb           LBB0_102
+	//0x00000a65 LBB0_105
+	0x48, 0xff, 0xc8, //0x00000a65 decq         %rax
+	0x48, 0x8d, 0x15, 0xf1, 0x02, 0x00, 0x00, //0x00000a68 leaq         $753(%rip), %rdx  /* _Digits+0(%rip) */
+	0x90, //0x00000a6f .p2align 4, 0x90
+	//0x00000a70 LBB0_106
+	0x44, 0x89, 0xd1, //0x00000a70 movl         %r10d, %ecx
+	0x48, 0x69, 0xc9, 0x1f, 0x85, 0xeb, 0x51, //0x00000a73 imulq        $1374389535, %rcx, %rcx
+	0x48, 0xc1, 0xe9, 0x25, //0x00000a7a shrq         $37, %rcx
+	0x6b, 0xd9, 0x64, //0x00000a7e imull        $100, %ecx, %ebx
+	0x44, 0x89, 0xd6, //0x00000a81 movl         %r10d, %esi
+	0x29, 0xde, //0x00000a84 subl         %ebx, %esi
+	0x0f, 0xb7, 0x34, 0x72, //0x00000a86 movzwl       (%rdx,%rsi,2), %esi
+	0x66, 0x89, 0x70, 0xff, //0x00000a8a movw         %si, $-1(%rax)
+	0x48, 0x83, 0xc0, 0xfe, //0x00000a8e addq         $-2, %rax
+	0x41, 0x81, 0xfa, 0x0f, 0x27, 0x00, 0x00, //0x00000a92 cmpl         $9999, %r10d
+	0x41, 0x89, 0xca, //0x00000a99 movl         %ecx, %r10d
+	0x0f, 0x87, 0xce, 0xff, 0xff, 0xff, //0x00000a9c ja           LBB0_106
+	//0x00000aa2 LBB0_107
+	0x83, 0xf9, 0x0a, //0x00000aa2 cmpl         $10, %ecx
+	0x0f, 0x82, 0x16, 0x00, 0x00, 0x00, //0x00000aa5 jb           LBB0_109
+	0x89, 0xc8, //0x00000aab movl         %ecx, %eax
+	0x48, 0x8d, 0x0d, 0xac, 0x02, 0x00, 0x00, //0x00000aad leaq         $684(%rip), %rcx  /* _Digits+0(%rip) */
+	0x0f, 0xb7, 0x04, 0x41, //0x00000ab4 movzwl       (%rcx,%rax,2), %eax
+	0x66, 0x41, 0x89, 0x00, //0x00000ab8 movw         %ax, (%r8)
+	0xe9, 0x06, 0x00, 0x00, 0x00, //0x00000abc jmp          LBB0_110
+	//0x00000ac1 LBB0_109
+	0x80, 0xc1, 0x30, //0x00000ac1 addb         $48, %cl
+	0x41, 0x88, 0x08, //0x00000ac4 movb         %cl, (%r8)
+	//0x00000ac7 LBB0_110
+	0x4d, 0x29, 0xcc, //0x00000ac7 subq         %r9, %r12
+	0x49, 0x8d, 0x74, 0x24, 0x01, //0x00000aca leaq         $1(%r12), %rsi
+	0x49, 0x8d, 0x54, 0x24, 0x61, //0x00000acf leaq         $97(%r12), %rdx
+	0x49, 0x8d, 0x44, 0x24, 0x02, //0x00000ad4 leaq         $2(%r12), %rax
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000ad9 .p2align 4, 0x90
+	//0x00000ae0 LBB0_111
+	0x48, 0xff, 0xca, //0x00000ae0 decq         %rdx
+	0x48, 0xff, 0xce, //0x00000ae3 decq         %rsi
+	0x48, 0xff, 0xc8, //0x00000ae6 decq         %rax
+	0x43, 0x80, 0x7c, 0x20, 0xff, 0x30, //0x00000ae9 cmpb         $48, $-1(%r8,%r12)
+	0x4d, 0x8d, 0x64, 0x24, 0xff, //0x00000aef leaq         $-1(%r12), %r12
+	0x0f, 0x84, 0xe6, 0xff, 0xff, 0xff, //0x00000af4 je           LBB0_111
+	0x4d, 0x8d, 0x0c, 0x30, //0x00000afa leaq         (%r8,%rsi), %r9
+	0x45, 0x85, 0xff, //0x00000afe testl        %r15d, %r15d
+	0x0f, 0x8e, 0x8b, 0x00, 0x00, 0x00, //0x00000b01 jle          LBB0_116
+	0x44, 0x89, 0xc9, //0x00000b07 movl         %r9d, %ecx
+	0x44, 0x29, 0xc1, //0x00000b0a subl         %r8d, %ecx
+	0x41, 0x39, 0xcf, //0x00000b0d cmpl         %ecx, %r15d
+	0x0f, 0x8d, 0x23, 0x00, 0x00, 0x00, //0x00000b10 jge          LBB0_117
+	0x43, 0x8d, 0x0c, 0x07, //0x00000b16 leal         (%r15,%r8), %ecx
+	0x41, 0x29, 0xc9, //0x00000b1a subl         %ecx, %r9d
+	0x49, 0x8d, 0x49, 0xff, //0x00000b1d leaq         $-1(%r9), %rcx
+	0x45, 0x89, 0xca, //0x00000b21 movl         %r9d, %r10d
+	0x41, 0x83, 0xe2, 0x03, //0x00000b24 andl         $3, %r10d
+	0x48, 0x83, 0xf9, 0x03, //0x00000b28 cmpq         $3, %rcx
+	0x0f, 0x83, 0x81, 0x00, 0x00, 0x00, //0x00000b2c jae          LBB0_121
+	0x31, 0xc9, //0x00000b32 xorl         %ecx, %ecx
+	0xe9, 0xa3, 0x00, 0x00, 0x00, //0x00000b34 jmp          LBB0_124
+	//0x00000b39 LBB0_117
+	0x0f, 0x8e, 0x53, 0x00, 0x00, 0x00, //0x00000b39 jle          LBB0_116
+	0x45, 0x01, 0xc7, //0x00000b3f addl         %r8d, %r15d
+	0x45, 0x89, 0xce, //0x00000b42 movl         %r9d, %r14d
+	0x41, 0xf7, 0xd6, //0x00000b45 notl         %r14d
+	0x45, 0x01, 0xfe, //0x00000b48 addl         %r15d, %r14d
+	0x45, 0x31, 0xd2, //0x00000b4b xorl         %r10d, %r10d
+	0x4d, 0x89, 0xcb, //0x00000b4e movq         %r9, %r11
+	0x41, 0x83, 0xfe, 0x7e, //0x00000b51 cmpl         $126, %r14d
+	0x0f, 0x86, 0xb4, 0x01, 0x00, 0x00, //0x00000b55 jbe          LBB0_135
+	0x49, 0xff, 0xc6, //0x00000b5b incq         %r14
+	0x4d, 0x89, 0xf2, //0x00000b5e movq         %r14, %r10
+	0x49, 0x83, 0xe2, 0x80, //0x00000b61 andq         $-128, %r10
+	0x4f, 0x8d, 0x1c, 0x10, //0x00000b65 leaq         (%r8,%r10), %r11
+	0x49, 0x8d, 0x5a, 0x80, //0x00000b69 leaq         $-128(%r10), %rbx
+	0x48, 0x89, 0xd9, //0x00000b6d movq         %rbx, %rcx
+	0x48, 0xc1, 0xe9, 0x07, //0x00000b70 shrq         $7, %rcx
+	0x48, 0xff, 0xc1, //0x00000b74 incq         %rcx
+	0x41, 0x89, 0xcc, //0x00000b77 movl         %ecx, %r12d
+	0x41, 0x83, 0xe4, 0x03, //0x00000b7a andl         $3, %r12d
+	0x48, 0x81, 0xfb, 0x80, 0x01, 0x00, 0x00, //0x00000b7e cmpq         $384, %rbx
+	0x0f, 0x83, 0x8f, 0x00, 0x00, 0x00, //0x00000b85 jae          LBB0_129
+	0x31, 0xc9, //0x00000b8b xorl         %ecx, %ecx
+	0xe9, 0x30, 0x01, 0x00, 0x00, //0x00000b8d jmp          LBB0_131
+	//0x00000b92 LBB0_116
+	0x4d, 0x89, 0xc8, //0x00000b92 movq         %r9, %r8
+	0xe9, 0x96, 0x01, 0x00, 0x00, //0x00000b95 jmp          LBB0_137
+	//0x00000b9a LBB0_103
+	0x41, 0xb9, 0x04, 0x00, 0x00, 0x00, //0x00000b9a movl         $4, %r9d
+	0x48, 0x83, 0xc0, 0xfc, //0x00000ba0 addq         $-4, %rax
+	0x41, 0x83, 0xfa, 0x64, //0x00000ba4 cmpl         $100, %r10d
+	0x0f, 0x82, 0x9f, 0xfe, 0xff, 0xff, //0x00000ba8 jb           LBB0_102
+	0xe9, 0xb2, 0xfe, 0xff, 0xff, //0x00000bae jmp          LBB0_105
+	//0x00000bb3 LBB0_121
+	0x4d, 0x89, 0xd3, //0x00000bb3 movq         %r10, %r11
+	0x4d, 0x29, 0xcb, //0x00000bb6 subq         %r9, %r11
+	0x31, 0xc9, //0x00000bb9 xorl         %ecx, %ecx
+	0x90, 0x90, 0x90, 0x90, 0x90, //0x00000bbb .p2align 4, 0x90
+	//0x00000bc0 LBB0_122
+	0x49, 0x8d, 0x1c, 0x08, //0x00000bc0 leaq         (%r8,%rcx), %rbx
+	0x8b, 0x54, 0x1e, 0xfc, //0x00000bc4 movl         $-4(%rsi,%rbx), %edx
+	0x89, 0x54, 0x1e, 0xfd, //0x00000bc8 movl         %edx, $-3(%rsi,%rbx)
+	0x48, 0x83, 0xc1, 0xfc, //0x00000bcc addq         $-4, %rcx
+	0x49, 0x39, 0xcb, //0x00000bd0 cmpq         %rcx, %r11
+	0x0f, 0x85, 0xe7, 0xff, 0xff, 0xff, //0x00000bd3 jne          LBB0_122
+	0x48, 0xf7, 0xd9, //0x00000bd9 negq         %rcx
+	//0x00000bdc LBB0_124
+	0x4d, 0x85, 0xd2, //0x00000bdc testq        %r10, %r10
+	0x0f, 0x84, 0x25, 0x00, 0x00, 0x00, //0x00000bdf je           LBB0_127
+	0x49, 0xf7, 0xda, //0x00000be5 negq         %r10
+	0x4c, 0x89, 0xc2, //0x00000be8 movq         %r8, %rdx
+	0x48, 0x29, 0xca, //0x00000beb subq         %rcx, %rdx
+	0x31, 0xc9, //0x00000bee xorl         %ecx, %ecx
+	//0x00000bf0 .p2align 4, 0x90
+	//0x00000bf0 LBB0_126
+	0x48, 0x8d, 0x34, 0x0a, //0x00000bf0 leaq         (%rdx,%rcx), %rsi
+	0x41, 0x0f, 0xb6, 0x1c, 0x34, //0x00000bf4 movzbl       (%r12,%rsi), %ebx
+	0x41, 0x88, 0x5c, 0x34, 0x01, //0x00000bf9 movb         %bl, $1(%r12,%rsi)
+	0x48, 0xff, 0xc9, //0x00000bfe decq         %rcx
+	0x49, 0x39, 0xca, //0x00000c01 cmpq         %rcx, %r10
+	0x0f, 0x85, 0xe6, 0xff, 0xff, 0xff, //0x00000c04 jne          LBB0_126
+	//0x00000c0a LBB0_127
+	0x49, 0x63, 0xcf, //0x00000c0a movslq       %r15d, %rcx
+	0x41, 0xc6, 0x04, 0x08, 0x2e, //0x00000c0d movb         $46, (%r8,%rcx)
+	0x49, 0x01, 0xc0, //0x00000c12 addq         %rax, %r8
+	0xe9, 0x16, 0x01, 0x00, 0x00, //0x00000c15 jmp          LBB0_137
+	//0x00000c1a LBB0_129
+	0x4c, 0x89, 0xe3, //0x00000c1a movq         %r12, %rbx
+	0x48, 0x29, 0xcb, //0x00000c1d subq         %rcx, %rbx
+	0x31, 0xc9, //0x00000c20 xorl         %ecx, %ecx
+	0xc5, 0xfe, 0x6f, 0x05, 0xd6, 0xf3, 0xff, 0xff, //0x00000c22 vmovdqu      $-3114(%rip), %ymm0  /* LCPI0_0+0(%rip) */
+	//0x00000c2a LBB0_130
+	0x49, 0x8d, 0x04, 0x08, //0x00000c2a leaq         (%r8,%rcx), %rax
+	0xc5, 0xfe, 0x7f, 0x04, 0x06, //0x00000c2e vmovdqu      %ymm0, (%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x44, 0x06, 0x20, //0x00000c33 vmovdqu      %ymm0, $32(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x44, 0x06, 0x40, //0x00000c39 vmovdqu      %ymm0, $64(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x44, 0x06, 0x60, //0x00000c3f vmovdqu      %ymm0, $96(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0x80, 0x00, 0x00, 0x00, //0x00000c45 vmovdqu      %ymm0, $128(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0xa0, 0x00, 0x00, 0x00, //0x00000c4e vmovdqu      %ymm0, $160(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0xc0, 0x00, 0x00, 0x00, //0x00000c57 vmovdqu      %ymm0, $192(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0xe0, 0x00, 0x00, 0x00, //0x00000c60 vmovdqu      %ymm0, $224(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0x00, 0x01, 0x00, 0x00, //0x00000c69 vmovdqu      %ymm0, $256(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0x20, 0x01, 0x00, 0x00, //0x00000c72 vmovdqu      %ymm0, $288(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0x40, 0x01, 0x00, 0x00, //0x00000c7b vmovdqu      %ymm0, $320(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0x60, 0x01, 0x00, 0x00, //0x00000c84 vmovdqu      %ymm0, $352(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0x80, 0x01, 0x00, 0x00, //0x00000c8d vmovdqu      %ymm0, $384(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0xa0, 0x01, 0x00, 0x00, //0x00000c96 vmovdqu      %ymm0, $416(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0xc0, 0x01, 0x00, 0x00, //0x00000c9f vmovdqu      %ymm0, $448(%rsi,%rax)
+	0xc5, 0xfe, 0x7f, 0x84, 0x06, 0xe0, 0x01, 0x00, 0x00, //0x00000ca8 vmovdqu      %ymm0, $480(%rsi,%rax)
+	0x48, 0x81, 0xc1, 0x00, 0x02, 0x00, 0x00, //0x00000cb1 addq         $512, %rcx
+	0x48, 0x83, 0xc3, 0x04, //0x00000cb8 addq         $4, %rbx
+	0x0f, 0x85, 0x68, 0xff, 0xff, 0xff, //0x00000cbc jne          LBB0_130
+	//0x00000cc2 LBB0_131
+	0x49, 0x01, 0xf3, //0x00000cc2 addq         %rsi, %r11
+	0x4d, 0x85, 0xe4, //0x00000cc5 testq        %r12, %r12
+	0x0f, 0x84, 0x35, 0x00, 0x00, 0x00, //0x00000cc8 je           LBB0_134
+	0x49, 0x01, 0xc8, //0x00000cce addq         %rcx, %r8
+	0x49, 0x01, 0xd0, //0x00000cd1 addq         %rdx, %r8
+	0x49, 0xf7, 0xdc, //0x00000cd4 negq         %r12
+	0xc5, 0xfe, 0x6f, 0x05, 0x21, 0xf3, 0xff, 0xff, //0x00000cd7 vmovdqu      $-3295(%rip), %ymm0  /* LCPI0_0+0(%rip) */
+	//0x00000cdf LBB0_133
+	0xc4, 0xc1, 0x7e, 0x7f, 0x40, 0xa0, //0x00000cdf vmovdqu      %ymm0, $-96(%r8)
+	0xc4, 0xc1, 0x7e, 0x7f, 0x40, 0xc0, //0x00000ce5 vmovdqu      %ymm0, $-64(%r8)
+	0xc4, 0xc1, 0x7e, 0x7f, 0x40, 0xe0, //0x00000ceb vmovdqu      %ymm0, $-32(%r8)
+	0xc4, 0xc1, 0x7e, 0x7f, 0x00, //0x00000cf1 vmovdqu      %ymm0, (%r8)
+	0x49, 0x83, 0xe8, 0x80, //0x00000cf6 subq         $-128, %r8
+	0x49, 0xff, 0xc4, //0x00000cfa incq         %r12
+	0x0f, 0x85, 0xdc, 0xff, 0xff, 0xff, //0x00000cfd jne          LBB0_133
+	//0x00000d03 LBB0_134
+	0x4d, 0x89, 0xd8, //0x00000d03 movq         %r11, %r8
+	0x4d, 0x39, 0xd6, //0x00000d06 cmpq         %r10, %r14
+	0x0f, 0x84, 0x21, 0x00, 0x00, 0x00, //0x00000d09 je           LBB0_137
+	//0x00000d0f LBB0_135
+	0x45, 0x29, 0xd7, //0x00000d0f subl         %r10d, %r15d
+	0x45, 0x29, 0xcf, //0x00000d12 subl         %r9d, %r15d
+	0x4d, 0x89, 0xd8, //0x00000d15 movq         %r11, %r8
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000d18 .p2align 4, 0x90
+	//0x00000d20 LBB0_136
+	0x41, 0xc6, 0x00, 0x30, //0x00000d20 movb         $48, (%r8)
+	0x49, 0xff, 0xc0, //0x00000d24 incq         %r8
+	0x41, 0xff, 0xcf, //0x00000d27 decl         %r15d
+	0x0f, 0x85, 0xf0, 0xff, 0xff, 0xff, //0x00000d2a jne          LBB0_136
+	//0x00000d30 LBB0_137
+	0x41, 0x29, 0xf8, //0x00000d30 subl         %edi, %r8d
+	//0x00000d33 LBB0_138
+	0x44, 0x89, 0xc0, //0x00000d33 movl         %r8d, %eax
+	0x5b, //0x00000d36 popq         %rbx
+	0x41, 0x5c, //0x00000d37 popq         %r12
+	0x41, 0x5d, //0x00000d39 popq         %r13
+	0x41, 0x5e, //0x00000d3b popq         %r14
+	0x41, 0x5f, //0x00000d3d popq         %r15
+	0x5d, //0x00000d3f popq         %rbp
+	0xc5, 0xf8, 0x77, //0x00000d40 vzeroupper   
+	0xc3, //0x00000d43 retq         
+	//0x00000d44 LBB0_139
+	0x45, 0x31, 0xc0, //0x00000d44 xorl         %r8d, %r8d
+	0xe9, 0xe7, 0xff, 0xff, 0xff, //0x00000d47 jmp          LBB0_138
+	//0x00000d4c LBB0_140
+	0x41, 0xbf, 0x6b, 0xff, 0xff, 0xff, //0x00000d4c movl         $-149, %r15d
+	0x89, 0xc6, //0x00000d52 movl         %eax, %esi
+	0xe9, 0x46, 0xf3, 0xff, 0xff, //0x00000d54 jmp          LBB0_5
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d59 .p2align 4, 0x00
+	//0x00000d60 _Digits
+	0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x35, 0x30, 0x36, 0x30, 0x37, //0x00000d60 QUAD $0x3330323031303030; QUAD $0x3730363035303430  // .ascii 16, '0001020304050607'
+	0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x31, 0x31, 0x31, 0x32, 0x31, 0x33, 0x31, 0x34, 0x31, 0x35, //0x00000d70 QUAD $0x3131303139303830; QUAD $0x3531343133313231  // .ascii 16, '0809101112131415'
+	0x31, 0x36, 0x31, 0x37, 0x31, 0x38, 0x31, 0x39, 0x32, 0x30, 0x32, 0x31, 0x32, 0x32, 0x32, 0x33, //0x00000d80 QUAD $0x3931383137313631; QUAD $0x3332323231323032  // .ascii 16, '1617181920212223'
+	0x32, 0x34, 0x32, 0x35, 0x32, 0x36, 0x32, 0x37, 0x32, 0x38, 0x32, 0x39, 0x33, 0x30, 0x33, 0x31, //0x00000d90 QUAD $0x3732363235323432; QUAD $0x3133303339323832  // .ascii 16, '2425262728293031'
+	0x33, 0x32, 0x33, 0x33, 0x33, 0x34, 0x33, 0x35, 0x33, 0x36, 0x33, 0x37, 0x33, 0x38, 0x33, 0x39, //0x00000da0 QUAD $0x3533343333333233; QUAD $0x3933383337333633  // .ascii 16, '3233343536373839'
+	0x34, 0x30, 0x34, 0x31, 0x34, 0x32, 0x34, 0x33, 0x34, 0x34, 0x34, 0x35, 0x34, 0x36, 0x34, 0x37, //0x00000db0 QUAD $0x3334323431343034; QUAD $0x3734363435343434  // .ascii 16, '4041424344454647'
+	0x34, 0x38, 0x34, 0x39, 0x35, 0x30, 0x35, 0x31, 0x35, 0x32, 0x35, 0x33, 0x35, 0x34, 0x35, 0x35, //0x00000dc0 QUAD $0x3135303539343834; QUAD $0x3535343533353235  // .ascii 16, '4849505152535455'
+	0x35, 0x36, 0x35, 0x37, 0x35, 0x38, 0x35, 0x39, 0x36, 0x30, 0x36, 0x31, 0x36, 0x32, 0x36, 0x33, //0x00000dd0 QUAD $0x3935383537353635; QUAD $0x3336323631363036  // .ascii 16, '5657585960616263'
+	0x36, 0x34, 0x36, 0x35, 0x36, 0x36, 0x36, 0x37, 0x36, 0x38, 0x36, 0x39, 0x37, 0x30, 0x37, 0x31, //0x00000de0 QUAD $0x3736363635363436; QUAD $0x3137303739363836  // .ascii 16, '6465666768697071'
+	0x37, 0x32, 0x37, 0x33, 0x37, 0x34, 0x37, 0x35, 0x37, 0x36, 0x37, 0x37, 0x37, 0x38, 0x37, 0x39, //0x00000df0 QUAD $0x3537343733373237; QUAD $0x3937383737373637  // .ascii 16, '7273747576777879'
+	0x38, 0x30, 0x38, 0x31, 0x38, 0x32, 0x38, 0x33, 0x38, 0x34, 0x38, 0x35, 0x38, 0x36, 0x38, 0x37, //0x00000e00 QUAD $0x3338323831383038; QUAD $0x3738363835383438  // .ascii 16, '8081828384858687'
+	0x38, 0x38, 0x38, 0x39, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x34, 0x39, 0x35, //0x00000e10 QUAD $0x3139303939383838; QUAD $0x3539343933393239  // .ascii 16, '8889909192939495'
+	0x39, 0x36, 0x39, 0x37, 0x39, 0x38, 0x39, 0x39, //0x00000e20 QUAD $0x3939383937393639  // .ascii 8, '96979899'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e28 .p2align 4, 0x00
+	//0x00000e30 _pow10_ceil_sig_f32.g
+	0xf5, 0xfc, 0x43, 0x4b, 0x2c, 0xb3, 0xce, 0x81, //0x00000e30 .quad -9093133594791772939
+	0x32, 0xfc, 0x14, 0x5e, 0xf7, 0x5f, 0x42, 0xa2, //0x00000e38 .quad -6754730975062328270
+	0x3f, 0x3b, 0x9a, 0x35, 0xf5, 0xf7, 0xd2, 0xca, //0x00000e40 .quad -3831727700400522433
+	0x0e, 0xca, 0x00, 0x83, 0xf2, 0xb5, 0x87, 0xfd, //0x00000e48 .quad -177973607073265138
+	0x49, 0x7e, 0xe0, 0x91, 0xb7, 0xd1, 0x74, 0x9e, //0x00000e50 .quad -7028762532061872567
+	0xdb, 0x9d, 0x58, 0x76, 0x25, 0x06, 0x12, 0xc6, //0x00000e58 .quad -4174267146649952805
+	0x52, 0xc5, 0xee, 0xd3, 0xae, 0x87, 0x96, 0xf7, //0x00000e60 .quad -606147914885053102
+	0x53, 0x3b, 0x75, 0x44, 0xcd, 0x14, 0xbe, 0x9a, //0x00000e68 .quad -7296371474444240045
+	0x28, 0x8a, 0x92, 0x95, 0x00, 0x9a, 0x6d, 0xc1, //0x00000e70 .quad -4508778324627912152
+	0xb2, 0x2c, 0xf7, 0xba, 0x80, 0x00, 0xc9, 0xf1, //0x00000e78 .quad -1024286887357502286
+	0xef, 0x7b, 0xda, 0x74, 0x50, 0xa0, 0x1d, 0x97, //0x00000e80 .quad -7557708332239520785
+	0xeb, 0x1a, 0x11, 0x92, 0x64, 0x08, 0xe5, 0xbc, //0x00000e88 .quad -4835449396872013077
+	0xa6, 0x61, 0x95, 0xb6, 0x7d, 0x4a, 0x1e, 0xec, //0x00000e90 .quad -1432625727662628442
+	0x08, 0x5d, 0x1d, 0x92, 0x8e, 0xee, 0x92, 0x93, //0x00000e98 .quad -7812920107430224632
+	0x4a, 0xb4, 0xa4, 0x36, 0x32, 0xaa, 0x77, 0xb8, //0x00000ea0 .quad -5154464115860392886
+	0x5c, 0xe1, 0x4d, 0xc4, 0xbe, 0x94, 0x95, 0xe6, //0x00000ea8 .quad -1831394126398103204
+	0xda, 0xac, 0xb0, 0x3a, 0xf7, 0x7c, 0x1d, 0x90, //0x00000eb0 .quad -8062150356639896358
+	0x10, 0xd8, 0x5c, 0x09, 0x35, 0xdc, 0x24, 0xb4, //0x00000eb8 .quad -5466001927372482544
+	0x14, 0x0e, 0xb4, 0x4b, 0x42, 0x13, 0x2e, 0xe1, //0x00000ec0 .quad -2220816390788215276
+	0xcc, 0x88, 0x50, 0x6f, 0x09, 0xcc, 0xbc, 0x8c, //0x00000ec8 .quad -8305539271883716404
+	0xff, 0xaa, 0x24, 0xcb, 0x0b, 0xff, 0xeb, 0xaf, //0x00000ed0 .quad -5770238071427257601
+	0xbf, 0xd5, 0xed, 0xbd, 0xce, 0xfe, 0xe6, 0xdb, //0x00000ed8 .quad -2601111570856684097
+	0x98, 0xa5, 0xb4, 0x36, 0x41, 0x5f, 0x70, 0x89, //0x00000ee0 .quad -8543223759426509416
+	0xfd, 0xce, 0x61, 0x84, 0x11, 0x77, 0xcc, 0xab, //0x00000ee8 .quad -6067343680855748867
+	0xbd, 0x42, 0x7a, 0xe5, 0xd5, 0x94, 0xbf, 0xd6, //0x00000ef0 .quad -2972493582642298179
+	0xb6, 0x69, 0x6c, 0xaf, 0x05, 0xbd, 0x37, 0x86, //0x00000ef8 .quad -8775337516792518218
+	0x24, 0x84, 0x47, 0x1b, 0x47, 0xac, 0xc5, 0xa7, //0x00000f00 .quad -6357485877563259868
+	0x2c, 0x65, 0x19, 0xe2, 0x58, 0x17, 0xb7, 0xd1, //0x00000f08 .quad -3335171328526686932
+	0x3c, 0xdf, 0x4f, 0x8d, 0x97, 0x6e, 0x12, 0x83, //0x00000f10 .quad -9002011107970261188
+	0x0b, 0xd7, 0xa3, 0x70, 0x3d, 0x0a, 0xd7, 0xa3, //0x00000f18 .quad -6640827866535438581
+	0xcd, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, //0x00000f20 .quad -3689348814741910323
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, //0x00000f28 .quad -9223372036854775808
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, //0x00000f30 .quad -6917529027641081856
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, //0x00000f38 .quad -4035225266123964416
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, //0x00000f40 .quad -432345564227567616
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x9c, //0x00000f48 .quad -7187745005283311616
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0xc3, //0x00000f50 .quad -4372995238176751616
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0xf4, //0x00000f58 .quad -854558029293551616
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x96, 0x98, //0x00000f60 .quad -7451627795949551616
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xbc, 0xbe, //0x00000f68 .quad -4702848726509551616
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x6b, 0xee, //0x00000f70 .quad -1266874889709551616
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x02, 0x95, //0x00000f78 .quad -7709325833709551616
+	0x00, 0x00, 0x00, 0x00, 0x40, 0xb7, 0x43, 0xba, //0x00000f80 .quad -5024971273709551616
+	0x00, 0x00, 0x00, 0x00, 0x10, 0xa5, 0xd4, 0xe8, //0x00000f88 .quad -1669528073709551616
+	0x00, 0x00, 0x00, 0x00, 0x2a, 0xe7, 0x84, 0x91, //0x00000f90 .quad -7960984073709551616
+	0x00, 0x00, 0x00, 0x80, 0xf4, 0x20, 0xe6, 0xb5, //0x00000f98 .quad -5339544073709551616
+	0x00, 0x00, 0x00, 0xa0, 0x31, 0xa9, 0x5f, 0xe3, //0x00000fa0 .quad -2062744073709551616
+	0x00, 0x00, 0x00, 0x04, 0xbf, 0xc9, 0x1b, 0x8e, //0x00000fa8 .quad -8206744073709551616
+	0x00, 0x00, 0x00, 0xc5, 0x2e, 0xbc, 0xa2, 0xb1, //0x00000fb0 .quad -5646744073709551616
+	0x00, 0x00, 0x40, 0x76, 0x3a, 0x6b, 0x0b, 0xde, //0x00000fb8 .quad -2446744073709551616
+	0x00, 0x00, 0xe8, 0x89, 0x04, 0x23, 0xc7, 0x8a, //0x00000fc0 .quad -8446744073709551616
+	0x00, 0x00, 0x62, 0xac, 0xc5, 0xeb, 0x78, 0xad, //0x00000fc8 .quad -5946744073709551616
+	0x00, 0x80, 0x7a, 0x17, 0xb7, 0x26, 0xd7, 0xd8, //0x00000fd0 .quad -2821744073709551616
+	0x00, 0x90, 0xac, 0x6e, 0x32, 0x78, 0x86, 0x87, //0x00000fd8 .quad -8681119073709551616
+	0x00, 0xb4, 0x57, 0x0a, 0x3f, 0x16, 0x68, 0xa9, //0x00000fe0 .quad -6239712823709551616
+	0x00, 0xa1, 0xed, 0xcc, 0xce, 0x1b, 0xc2, 0xd3, //0x00000fe8 .quad -3187955011209551616
+	0xa0, 0x84, 0x14, 0x40, 0x61, 0x51, 0x59, 0x84, //0x00000ff0 .quad -8910000909647051616
+	0xc8, 0xa5, 0x19, 0x90, 0xb9, 0xa5, 0x6f, 0xa5, //0x00000ff8 .quad -6525815118631426616
+	0x3a, 0x0f, 0x20, 0xf4, 0x27, 0x8f, 0xcb, 0xce, //0x00001000 .quad -3545582879861895366
+	0x85, 0x09, 0x94, 0xf8, 0x78, 0x39, 0x3f, 0x81, //0x00001008 .quad -9133518327554766459
+	0xe6, 0x0b, 0xb9, 0x36, 0xd7, 0x07, 0x8f, 0xa1, //0x00001010 .quad -6805211891016070170
+	0xdf, 0x4e, 0x67, 0x04, 0xcd, 0xc9, 0xf2, 0xc9, //0x00001018 .quad -3894828845342699809
+	0x97, 0x22, 0x81, 0x45, 0x40, 0x7c, 0x6f, 0xfc, //0x00001020 .quad -256850038250986857
+	0x9e, 0xb5, 0x70, 0x2b, 0xa8, 0xad, 0xc5, 0x9d, //0x00001028 .quad -7078060301547948642
+	0x06, 0xe3, 0x4c, 0x36, 0x12, 0x19, 0x37, 0xc5, //0x00001030 .quad -4235889358507547898
+	0xc7, 0x1b, 0xe0, 0xc3, 0x56, 0xdf, 0x84, 0xf6, //0x00001038 .quad -683175679707046969
+	0x5d, 0x11, 0x6c, 0x3a, 0x96, 0x0b, 0x13, 0x9a, //0x00001040 .quad -7344513827457986211
+	0xb4, 0x15, 0x07, 0xc9, 0x7b, 0xce, 0x97, 0xc0, //0x00001048 .quad -4568956265895094860
+	0x21, 0xdb, 0x48, 0xbb, 0x1a, 0xc2, 0xbd, 0xf0, //0x00001050 .quad -1099509313941480671
+	0xf5, 0x88, 0x0d, 0xb5, 0x50, 0x99, 0x76, 0x96, //0x00001058 .quad -7604722348854507275
+	0x32, 0xeb, 0x50, 0xe2, 0xa4, 0x3f, 0x14, 0xbc, //0x00001060 .quad -4894216917640746190
+	0xfe, 0x25, 0xe5, 0x1a, 0x8e, 0x4f, 0x19, 0xeb, //0x00001068 .quad -1506085128623544834
+	0xbf, 0x37, 0xcf, 0xd0, 0xb8, 0xd1, 0xef, 0x92, //0x00001070 .quad -7858832233030797377
+	0xae, 0x05, 0x03, 0x05, 0x27, 0xc6, 0xab, 0xb7, //0x00001078 .quad -5211854272861108818
+	0x1a, 0xc7, 0x43, 0xc6, 0xb0, 0xb7, 0x96, 0xe5, //0x00001080 .quad -1903131822648998118
+	0x70, 0x5c, 0xea, 0x7b, 0xce, 0x32, 0x7e, 0x8f, //0x00001088 .quad -8106986416796705680
+	0x8c, 0xf3, 0xe4, 0x1a, 0x82, 0xbf, 0x5d, 0xb3, //0x00001090 .quad -5522047002568494196
+}
+ 

vendor/github.com/bytedance/sonic/internal/native/avx/f64toa.go

@@ -0,0 +1,37 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_f64toa func(out unsafe.Pointer, val float64) (ret int) 
+
+var S_f64toa uintptr
+
+//go:nosplit
+func f64toa(out *byte, val float64) (ret int) {
+	return F_f64toa((rt.NoEscape(unsafe.Pointer(out))), val)
+}
+

vendor/github.com/bytedance/sonic/internal/native/avx/f64toa_subr.go

@@ -0,0 +1,46 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__f64toa = 32
+)
+
+const (
+    _stack__f64toa = 56
+)
+
+const (
+    _size__f64toa = 4704
+)
+
+var (
+    _pcsp__f64toa = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {4614, 56},
+        {4618, 48},
+        {4619, 40},
+        {4621, 32},
+        {4623, 24},
+        {4625, 16},
+        {4627, 8},
+        {4631, 0},
+        {4694, 56},
+    }
+)
+
+var _cfunc_f64toa = []loader.CFunc{
+    {"_f64toa_entry", 0,  _entry__f64toa, 0, nil},
+    {"_f64toa", _entry__f64toa, _size__f64toa, _stack__f64toa, _pcsp__f64toa},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/get_by_path.go

@@ -0,0 +1,37 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_get_by_path func(s unsafe.Pointer, p unsafe.Pointer, path unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+var S_get_by_path uintptr
+
+//go:nosplit
+func get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) {
+    return F_get_by_path(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(path)), rt.NoEscape(unsafe.Pointer(m)))
+}

vendor/github.com/bytedance/sonic/internal/native/avx/get_by_path_subr.go

@@ -0,0 +1,45 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__get_by_path = 224
+)
+
+const (
+    _stack__get_by_path = 272
+)
+
+const (
+    _size__get_by_path = 20184
+)
+
+var (
+    _pcsp__get_by_path = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {17077, 272},
+        {17078, 264},
+        {17080, 256},
+        {17082, 248},
+        {17084, 240},
+        {17086, 232},
+        {17090, 224},
+        {20184, 272},
+    }
+)
+
+var _cfunc_get_by_path = []loader.CFunc{
+    {"_get_by_path_entry", 0,  _entry__get_by_path, 0, nil},
+    {"_get_by_path", _entry__get_by_path, _size__get_by_path, _stack__get_by_path, _pcsp__get_by_path},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/html_escape.go

@@ -0,0 +1,36 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_html_escape func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer) (ret int)
+
+var S_html_escape uintptr
+
+//go:nosplit
+func html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) {
+    return F_html_escape(rt.NoEscape(sp), nb, dp, rt.NoEscape(unsafe.Pointer(dn)))
+}

vendor/github.com/bytedance/sonic/internal/native/avx/html_escape_subr.go

@@ -0,0 +1,45 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__html_escape = 64
+)
+
+const (
+    _stack__html_escape = 72
+)
+
+const (
+    _size__html_escape = 1248
+)
+
+var (
+    _pcsp__html_escape = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1224, 72},
+        {1228, 48},
+        {1229, 40},
+        {1231, 32},
+        {1233, 24},
+        {1235, 16},
+        {1237, 8},
+        {1239, 0},
+    }
+)
+
+var _cfunc_html_escape = []loader.CFunc{
+    {"_html_escape_entry", 0,  _entry__html_escape, 0, nil},
+    {"_html_escape", _entry__html_escape, _size__html_escape, _stack__html_escape, _pcsp__html_escape},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/html_escape_text_amd64.go

@@ -0,0 +1,620 @@
+// +build amd64
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+var _text_html_escape = []byte{
+	// .p2align 4, 0x00
+	// LCPI0_0
+	0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, // QUAD $0x2626262626262626; QUAD $0x2626262626262626  // .space 16, '&&&&&&&&&&&&&&&&'
+	//0x00000010 LCPI0_1
+	0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, //0x00000010 QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2  // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2'
+	//0x00000020 LCPI0_2
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, //0x00000020 QUAD $0x0202020202020202; QUAD $0x0202020202020202  // .space 16, '\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02'
+	//0x00000030 LCPI0_3
+	0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, //0x00000030 QUAD $0x3e3e3e3e3e3e3e3e; QUAD $0x3e3e3e3e3e3e3e3e  // .space 16, '>>>>>>>>>>>>>>>>'
+	//0x00000040 .p2align 4, 0x90
+	//0x00000040 _html_escape
+	0x55, //0x00000040 pushq        %rbp
+	0x48, 0x89, 0xe5, //0x00000041 movq         %rsp, %rbp
+	0x41, 0x57, //0x00000044 pushq        %r15
+	0x41, 0x56, //0x00000046 pushq        %r14
+	0x41, 0x55, //0x00000048 pushq        %r13
+	0x41, 0x54, //0x0000004a pushq        %r12
+	0x53, //0x0000004c pushq        %rbx
+	0x48, 0x83, 0xec, 0x18, //0x0000004d subq         $24, %rsp
+	0x48, 0x89, 0x4d, 0xc0, //0x00000051 movq         %rcx, $-64(%rbp)
+	0x49, 0x89, 0xd2, //0x00000055 movq         %rdx, %r10
+	0x48, 0x89, 0x55, 0xc8, //0x00000058 movq         %rdx, $-56(%rbp)
+	0x48, 0x89, 0x7d, 0xd0, //0x0000005c movq         %rdi, $-48(%rbp)
+	0x48, 0x89, 0xf8, //0x00000060 movq         %rdi, %rax
+	0x48, 0x85, 0xf6, //0x00000063 testq        %rsi, %rsi
+	0x0f, 0x8e, 0x73, 0x04, 0x00, 0x00, //0x00000066 jle          LBB0_59
+	0x48, 0x8b, 0x45, 0xc0, //0x0000006c movq         $-64(%rbp), %rax
+	0x4c, 0x8b, 0x08, //0x00000070 movq         (%rax), %r9
+	0xc5, 0xfa, 0x6f, 0x05, 0x85, 0xff, 0xff, 0xff, //0x00000073 vmovdqu      $-123(%rip), %xmm0  /* LCPI0_0+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x0d, 0x8d, 0xff, 0xff, 0xff, //0x0000007b vmovdqu      $-115(%rip), %xmm1  /* LCPI0_1+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x15, 0x95, 0xff, 0xff, 0xff, //0x00000083 vmovdqu      $-107(%rip), %xmm2  /* LCPI0_2+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x1d, 0x9d, 0xff, 0xff, 0xff, //0x0000008b vmovdqu      $-99(%rip), %xmm3  /* LCPI0_3+0(%rip) */
+	0x49, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x50, //0x00000093 movabsq      $5764607797912141824, %r14
+	0x4c, 0x8d, 0x1d, 0x7c, 0x04, 0x00, 0x00, //0x0000009d leaq         $1148(%rip), %r11  /* __HtmlQuoteTab+0(%rip) */
+	0x4c, 0x8b, 0x7d, 0xd0, //0x000000a4 movq         $-48(%rbp), %r15
+	0x4c, 0x8b, 0x55, 0xc8, //0x000000a8 movq         $-56(%rbp), %r10
+	0x90, 0x90, 0x90, 0x90, //0x000000ac .p2align 4, 0x90
+	//0x000000b0 LBB0_2
+	0x4d, 0x85, 0xc9, //0x000000b0 testq        %r9, %r9
+	0x0f, 0x8e, 0x45, 0x04, 0x00, 0x00, //0x000000b3 jle          LBB0_61
+	0x48, 0x83, 0xfe, 0x0f, //0x000000b9 cmpq         $15, %rsi
+	0x0f, 0x9f, 0xc3, //0x000000bd setg         %bl
+	0x4d, 0x89, 0xcc, //0x000000c0 movq         %r9, %r12
+	0x4d, 0x89, 0xd0, //0x000000c3 movq         %r10, %r8
+	0x48, 0x89, 0xf0, //0x000000c6 movq         %rsi, %rax
+	0x4d, 0x89, 0xfd, //0x000000c9 movq         %r15, %r13
+	0x49, 0x83, 0xf9, 0x10, //0x000000cc cmpq         $16, %r9
+	0x0f, 0x8c, 0x7a, 0x00, 0x00, 0x00, //0x000000d0 jl           LBB0_9
+	0x48, 0x83, 0xfe, 0x10, //0x000000d6 cmpq         $16, %rsi
+	0x0f, 0x8c, 0x70, 0x00, 0x00, 0x00, //0x000000da jl           LBB0_9
+	0x4d, 0x89, 0xfd, //0x000000e0 movq         %r15, %r13
+	0x48, 0x89, 0xf0, //0x000000e3 movq         %rsi, %rax
+	0x4d, 0x89, 0xd0, //0x000000e6 movq         %r10, %r8
+	0x4c, 0x89, 0xc9, //0x000000e9 movq         %r9, %rcx
+	0x90, 0x90, 0x90, 0x90, //0x000000ec .p2align 4, 0x90
+	//0x000000f0 LBB0_6
+	0xc4, 0xc1, 0x7a, 0x6f, 0x65, 0x00, //0x000000f0 vmovdqu      (%r13), %xmm4
+	0xc5, 0xd9, 0x74, 0xe8, //0x000000f6 vpcmpeqb     %xmm0, %xmm4, %xmm5
+	0xc5, 0xd9, 0x74, 0xf1, //0x000000fa vpcmpeqb     %xmm1, %xmm4, %xmm6
+	0xc5, 0xc9, 0xeb, 0xed, //0x000000fe vpor         %xmm5, %xmm6, %xmm5
+	0xc5, 0xd9, 0xeb, 0xf2, //0x00000102 vpor         %xmm2, %xmm4, %xmm6
+	0xc5, 0xc9, 0x74, 0xf3, //0x00000106 vpcmpeqb     %xmm3, %xmm6, %xmm6
+	0xc5, 0xd1, 0xeb, 0xee, //0x0000010a vpor         %xmm6, %xmm5, %xmm5
+	0xc4, 0xc1, 0x7a, 0x7f, 0x20, //0x0000010e vmovdqu      %xmm4, (%r8)
+	0xc5, 0xf9, 0xd7, 0xd5, //0x00000113 vpmovmskb    %xmm5, %edx
+	0x66, 0x85, 0xd2, //0x00000117 testw        %dx, %dx
+	0x0f, 0x85, 0x30, 0x01, 0x00, 0x00, //0x0000011a jne          LBB0_21
+	0x49, 0x83, 0xc5, 0x10, //0x00000120 addq         $16, %r13
+	0x49, 0x83, 0xc0, 0x10, //0x00000124 addq         $16, %r8
+	0x4c, 0x8d, 0x61, 0xf0, //0x00000128 leaq         $-16(%rcx), %r12
+	0x48, 0x83, 0xf8, 0x1f, //0x0000012c cmpq         $31, %rax
+	0x0f, 0x9f, 0xc3, //0x00000130 setg         %bl
+	0x48, 0x83, 0xf8, 0x20, //0x00000133 cmpq         $32, %rax
+	0x48, 0x8d, 0x40, 0xf0, //0x00000137 leaq         $-16(%rax), %rax
+	0x0f, 0x8c, 0x0f, 0x00, 0x00, 0x00, //0x0000013b jl           LBB0_9
+	0x48, 0x83, 0xf9, 0x1f, //0x00000141 cmpq         $31, %rcx
+	0x4c, 0x89, 0xe1, //0x00000145 movq         %r12, %rcx
+	0x0f, 0x8f, 0xa2, 0xff, 0xff, 0xff, //0x00000148 jg           LBB0_6
+	0x90, 0x90, //0x0000014e .p2align 4, 0x90
+	//0x00000150 LBB0_9
+	0x84, 0xdb, //0x00000150 testb        %bl, %bl
+	0x0f, 0x84, 0x68, 0x00, 0x00, 0x00, //0x00000152 je           LBB0_13
+	0x4c, 0x89, 0xf2, //0x00000158 movq         %r14, %rdx
+	0xc4, 0xc1, 0x7a, 0x6f, 0x65, 0x00, //0x0000015b vmovdqu      (%r13), %xmm4
+	0xc5, 0xd9, 0x74, 0xe8, //0x00000161 vpcmpeqb     %xmm0, %xmm4, %xmm5
+	0xc5, 0xd9, 0x74, 0xf1, //0x00000165 vpcmpeqb     %xmm1, %xmm4, %xmm6
+	0xc5, 0xc9, 0xeb, 0xed, //0x00000169 vpor         %xmm5, %xmm6, %xmm5
+	0xc5, 0xd9, 0xeb, 0xf2, //0x0000016d vpor         %xmm2, %xmm4, %xmm6
+	0xc5, 0xc9, 0x74, 0xf3, //0x00000171 vpcmpeqb     %xmm3, %xmm6, %xmm6
+	0xc5, 0xd1, 0xeb, 0xee, //0x00000175 vpor         %xmm6, %xmm5, %xmm5
+	0xc5, 0xf9, 0xd7, 0xc5, //0x00000179 vpmovmskb    %xmm5, %eax
+	0x0d, 0x00, 0x00, 0x01, 0x00, //0x0000017d orl          $65536, %eax
+	0x44, 0x0f, 0xbc, 0xf0, //0x00000182 bsfl         %eax, %r14d
+	0xc4, 0xe1, 0xf9, 0x7e, 0xe0, //0x00000186 vmovq        %xmm4, %rax
+	0x4d, 0x39, 0xf4, //0x0000018b cmpq         %r14, %r12
+	0x0f, 0x8d, 0xd7, 0x00, 0x00, 0x00, //0x0000018e jge          LBB0_22
+	0x49, 0x83, 0xfc, 0x08, //0x00000194 cmpq         $8, %r12
+	0x0f, 0x82, 0x09, 0x01, 0x00, 0x00, //0x00000198 jb           LBB0_25
+	0x49, 0x89, 0x00, //0x0000019e movq         %rax, (%r8)
+	0x4d, 0x8d, 0x75, 0x08, //0x000001a1 leaq         $8(%r13), %r14
+	0x49, 0x83, 0xc0, 0x08, //0x000001a5 addq         $8, %r8
+	0x49, 0x8d, 0x44, 0x24, 0xf8, //0x000001a9 leaq         $-8(%r12), %rax
+	0x48, 0x83, 0xf8, 0x04, //0x000001ae cmpq         $4, %rax
+	0x0f, 0x8d, 0xff, 0x00, 0x00, 0x00, //0x000001b2 jge          LBB0_26
+	0xe9, 0x0c, 0x01, 0x00, 0x00, //0x000001b8 jmp          LBB0_27
+	0x90, 0x90, 0x90, //0x000001bd .p2align 4, 0x90
+	//0x000001c0 LBB0_13
+	0x4d, 0x85, 0xe4, //0x000001c0 testq        %r12, %r12
+	0x0f, 0x8e, 0x67, 0x00, 0x00, 0x00, //0x000001c3 jle          LBB0_20
+	0x48, 0x85, 0xc0, //0x000001c9 testq        %rax, %rax
+	0x0f, 0x8e, 0x5e, 0x00, 0x00, 0x00, //0x000001cc jle          LBB0_20
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000001d2 .p2align 4, 0x90
+	//0x000001e0 LBB0_15
+	0x41, 0x0f, 0xb6, 0x4d, 0x00, //0x000001e0 movzbl       (%r13), %ecx
+	0x48, 0x83, 0xf9, 0x3e, //0x000001e5 cmpq         $62, %rcx
+	0x0f, 0x87, 0x0a, 0x00, 0x00, 0x00, //0x000001e9 ja           LBB0_17
+	0x49, 0x0f, 0xa3, 0xce, //0x000001ef btq          %rcx, %r14
+	0x0f, 0x82, 0x9a, 0x00, 0x00, 0x00, //0x000001f3 jb           LBB0_24
+	//0x000001f9 LBB0_17
+	0x80, 0xf9, 0xe2, //0x000001f9 cmpb         $-30, %cl
+	0x0f, 0x84, 0x91, 0x00, 0x00, 0x00, //0x000001fc je           LBB0_24
+	0x49, 0xff, 0xc5, //0x00000202 incq         %r13
+	0x41, 0x88, 0x08, //0x00000205 movb         %cl, (%r8)
+	0x48, 0x83, 0xf8, 0x02, //0x00000208 cmpq         $2, %rax
+	0x48, 0x8d, 0x40, 0xff, //0x0000020c leaq         $-1(%rax), %rax
+	0x0f, 0x8c, 0x1a, 0x00, 0x00, 0x00, //0x00000210 jl           LBB0_20
+	0x49, 0xff, 0xc0, //0x00000216 incq         %r8
+	0x49, 0x83, 0xfc, 0x01, //0x00000219 cmpq         $1, %r12
+	0x4d, 0x8d, 0x64, 0x24, 0xff, //0x0000021d leaq         $-1(%r12), %r12
+	0x0f, 0x8f, 0xb8, 0xff, 0xff, 0xff, //0x00000222 jg           LBB0_15
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000228 .p2align 4, 0x90
+	//0x00000230 LBB0_20
+	0x4d, 0x29, 0xfd, //0x00000230 subq         %r15, %r13
+	0x48, 0xf7, 0xd8, //0x00000233 negq         %rax
+	0x4d, 0x19, 0xe4, //0x00000236 sbbq         %r12, %r12
+	0x4d, 0x31, 0xec, //0x00000239 xorq         %r13, %r12
+	0x4d, 0x85, 0xe4, //0x0000023c testq        %r12, %r12
+	0x0f, 0x89, 0x5b, 0x01, 0x00, 0x00, //0x0000023f jns          LBB0_37
+	0xe9, 0x72, 0x02, 0x00, 0x00, //0x00000245 jmp          LBB0_57
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x0000024a .p2align 4, 0x90
+	//0x00000250 LBB0_21
+	0x0f, 0xb7, 0xc2, //0x00000250 movzwl       %dx, %eax
+	0x4d, 0x29, 0xfd, //0x00000253 subq         %r15, %r13
+	0x44, 0x0f, 0xbc, 0xe0, //0x00000256 bsfl         %eax, %r12d
+	0x4d, 0x01, 0xec, //0x0000025a addq         %r13, %r12
+	0x4d, 0x85, 0xe4, //0x0000025d testq        %r12, %r12
+	0x0f, 0x89, 0x3a, 0x01, 0x00, 0x00, //0x00000260 jns          LBB0_37
+	0xe9, 0x51, 0x02, 0x00, 0x00, //0x00000266 jmp          LBB0_57
+	//0x0000026b LBB0_22
+	0x41, 0x83, 0xfe, 0x08, //0x0000026b cmpl         $8, %r14d
+	0x0f, 0x82, 0xa9, 0x00, 0x00, 0x00, //0x0000026f jb           LBB0_31
+	0x49, 0x89, 0x00, //0x00000275 movq         %rax, (%r8)
+	0x4d, 0x8d, 0x65, 0x08, //0x00000278 leaq         $8(%r13), %r12
+	0x49, 0x83, 0xc0, 0x08, //0x0000027c addq         $8, %r8
+	0x49, 0x8d, 0x46, 0xf8, //0x00000280 leaq         $-8(%r14), %rax
+	0x48, 0x83, 0xf8, 0x04, //0x00000284 cmpq         $4, %rax
+	0x0f, 0x8d, 0xa0, 0x00, 0x00, 0x00, //0x00000288 jge          LBB0_32
+	0xe9, 0xae, 0x00, 0x00, 0x00, //0x0000028e jmp          LBB0_33
+	//0x00000293 LBB0_24
+	0x4d, 0x29, 0xfd, //0x00000293 subq         %r15, %r13
+	0x4d, 0x89, 0xec, //0x00000296 movq         %r13, %r12
+	0x4d, 0x85, 0xe4, //0x00000299 testq        %r12, %r12
+	0x0f, 0x89, 0xfe, 0x00, 0x00, 0x00, //0x0000029c jns          LBB0_37
+	0xe9, 0x15, 0x02, 0x00, 0x00, //0x000002a2 jmp          LBB0_57
+	//0x000002a7 LBB0_25
+	0x4d, 0x89, 0xee, //0x000002a7 movq         %r13, %r14
+	0x4c, 0x89, 0xe0, //0x000002aa movq         %r12, %rax
+	0x48, 0x83, 0xf8, 0x04, //0x000002ad cmpq         $4, %rax
+	0x0f, 0x8c, 0x12, 0x00, 0x00, 0x00, //0x000002b1 jl           LBB0_27
+	//0x000002b7 LBB0_26
+	0x41, 0x8b, 0x0e, //0x000002b7 movl         (%r14), %ecx
+	0x41, 0x89, 0x08, //0x000002ba movl         %ecx, (%r8)
+	0x49, 0x83, 0xc6, 0x04, //0x000002bd addq         $4, %r14
+	0x49, 0x83, 0xc0, 0x04, //0x000002c1 addq         $4, %r8
+	0x48, 0x83, 0xc0, 0xfc, //0x000002c5 addq         $-4, %rax
+	//0x000002c9 LBB0_27
+	0x48, 0x83, 0xf8, 0x02, //0x000002c9 cmpq         $2, %rax
+	0x0f, 0x82, 0x22, 0x00, 0x00, 0x00, //0x000002cd jb           LBB0_28
+	0x41, 0x0f, 0xb7, 0x0e, //0x000002d3 movzwl       (%r14), %ecx
+	0x66, 0x41, 0x89, 0x08, //0x000002d7 movw         %cx, (%r8)
+	0x49, 0x83, 0xc6, 0x02, //0x000002db addq         $2, %r14
+	0x49, 0x83, 0xc0, 0x02, //0x000002df addq         $2, %r8
+	0x48, 0x83, 0xc0, 0xfe, //0x000002e3 addq         $-2, %rax
+	0x48, 0x85, 0xc0, //0x000002e7 testq        %rax, %rax
+	0x0f, 0x85, 0x0e, 0x00, 0x00, 0x00, //0x000002ea jne          LBB0_29
+	0xe9, 0x0f, 0x00, 0x00, 0x00, //0x000002f0 jmp          LBB0_30
+	//0x000002f5 LBB0_28
+	0x48, 0x85, 0xc0, //0x000002f5 testq        %rax, %rax
+	0x0f, 0x84, 0x06, 0x00, 0x00, 0x00, //0x000002f8 je           LBB0_30
+	//0x000002fe LBB0_29
+	0x41, 0x8a, 0x06, //0x000002fe movb         (%r14), %al
+	0x41, 0x88, 0x00, //0x00000301 movb         %al, (%r8)
+	//0x00000304 LBB0_30
+	0x4d, 0x29, 0xfc, //0x00000304 subq         %r15, %r12
+	0x4d, 0x01, 0xec, //0x00000307 addq         %r13, %r12
+	0x49, 0xf7, 0xd4, //0x0000030a notq         %r12
+	0x49, 0x89, 0xd6, //0x0000030d movq         %rdx, %r14
+	0x4d, 0x85, 0xe4, //0x00000310 testq        %r12, %r12
+	0x0f, 0x89, 0x87, 0x00, 0x00, 0x00, //0x00000313 jns          LBB0_37
+	0xe9, 0x9e, 0x01, 0x00, 0x00, //0x00000319 jmp          LBB0_57
+	//0x0000031e LBB0_31
+	0x4d, 0x89, 0xec, //0x0000031e movq         %r13, %r12
+	0x4c, 0x89, 0xf0, //0x00000321 movq         %r14, %rax
+	0x48, 0x83, 0xf8, 0x04, //0x00000324 cmpq         $4, %rax
+	0x0f, 0x8c, 0x13, 0x00, 0x00, 0x00, //0x00000328 jl           LBB0_33
+	//0x0000032e LBB0_32
+	0x41, 0x8b, 0x0c, 0x24, //0x0000032e movl         (%r12), %ecx
+	0x41, 0x89, 0x08, //0x00000332 movl         %ecx, (%r8)
+	0x49, 0x83, 0xc4, 0x04, //0x00000335 addq         $4, %r12
+	0x49, 0x83, 0xc0, 0x04, //0x00000339 addq         $4, %r8
+	0x48, 0x83, 0xc0, 0xfc, //0x0000033d addq         $-4, %rax
+	//0x00000341 LBB0_33
+	0x48, 0x83, 0xf8, 0x02, //0x00000341 cmpq         $2, %rax
+	0x0f, 0x82, 0x23, 0x00, 0x00, 0x00, //0x00000345 jb           LBB0_34
+	0x41, 0x0f, 0xb7, 0x0c, 0x24, //0x0000034b movzwl       (%r12), %ecx
+	0x66, 0x41, 0x89, 0x08, //0x00000350 movw         %cx, (%r8)
+	0x49, 0x83, 0xc4, 0x02, //0x00000354 addq         $2, %r12
+	0x49, 0x83, 0xc0, 0x02, //0x00000358 addq         $2, %r8
+	0x48, 0x83, 0xc0, 0xfe, //0x0000035c addq         $-2, %rax
+	0x48, 0x85, 0xc0, //0x00000360 testq        %rax, %rax
+	0x0f, 0x85, 0x0e, 0x00, 0x00, 0x00, //0x00000363 jne          LBB0_35
+	0xe9, 0x10, 0x00, 0x00, 0x00, //0x00000369 jmp          LBB0_36
+	//0x0000036e LBB0_34
+	0x48, 0x85, 0xc0, //0x0000036e testq        %rax, %rax
+	0x0f, 0x84, 0x07, 0x00, 0x00, 0x00, //0x00000371 je           LBB0_36
+	//0x00000377 LBB0_35
+	0x41, 0x8a, 0x04, 0x24, //0x00000377 movb         (%r12), %al
+	0x41, 0x88, 0x00, //0x0000037b movb         %al, (%r8)
+	//0x0000037e LBB0_36
+	0x4d, 0x29, 0xfd, //0x0000037e subq         %r15, %r13
+	0x4d, 0x01, 0xf5, //0x00000381 addq         %r14, %r13
+	0x4d, 0x89, 0xec, //0x00000384 movq         %r13, %r12
+	0x49, 0x89, 0xd6, //0x00000387 movq         %rdx, %r14
+	0x4d, 0x85, 0xe4, //0x0000038a testq        %r12, %r12
+	0x0f, 0x88, 0x29, 0x01, 0x00, 0x00, //0x0000038d js           LBB0_57
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000393 .p2align 4, 0x90
+	//0x000003a0 LBB0_37
+	0x4d, 0x01, 0xe7, //0x000003a0 addq         %r12, %r15
+	0x4d, 0x01, 0xe2, //0x000003a3 addq         %r12, %r10
+	0x4c, 0x29, 0xe6, //0x000003a6 subq         %r12, %rsi
+	0x0f, 0x8e, 0x2d, 0x01, 0x00, 0x00, //0x000003a9 jle          LBB0_58
+	0x4d, 0x29, 0xe1, //0x000003af subq         %r12, %r9
+	0x41, 0x8a, 0x0f, //0x000003b2 movb         (%r15), %cl
+	0x80, 0xf9, 0xe2, //0x000003b5 cmpb         $-30, %cl
+	0x0f, 0x84, 0xb1, 0x00, 0x00, 0x00, //0x000003b8 je           LBB0_51
+	0x4c, 0x89, 0xf8, //0x000003be movq         %r15, %rax
+	//0x000003c1 LBB0_40
+	0x0f, 0xb6, 0xd1, //0x000003c1 movzbl       %cl, %edx
+	0x48, 0xc1, 0xe2, 0x04, //0x000003c4 shlq         $4, %rdx
+	0x4a, 0x8b, 0x3c, 0x1a, //0x000003c8 movq         (%rdx,%r11), %rdi
+	0x48, 0x63, 0xdf, //0x000003cc movslq       %edi, %rbx
+	0x49, 0x29, 0xd9, //0x000003cf subq         %rbx, %r9
+	0x0f, 0x8c, 0x1b, 0x01, 0x00, 0x00, //0x000003d2 jl           LBB0_60
+	0x48, 0xc1, 0xe7, 0x20, //0x000003d8 shlq         $32, %rdi
+	0x4e, 0x8d, 0x7c, 0x1a, 0x08, //0x000003dc leaq         $8(%rdx,%r11), %r15
+	0x48, 0xb9, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, //0x000003e1 movabsq      $12884901889, %rcx
+	0x48, 0x39, 0xcf, //0x000003eb cmpq         %rcx, %rdi
+	0x0f, 0x8c, 0x2c, 0x00, 0x00, 0x00, //0x000003ee jl           LBB0_43
+	0x41, 0x8b, 0x0f, //0x000003f4 movl         (%r15), %ecx
+	0x41, 0x89, 0x0a, //0x000003f7 movl         %ecx, (%r10)
+	0x4e, 0x8d, 0x7c, 0x1a, 0x0c, //0x000003fa leaq         $12(%rdx,%r11), %r15
+	0x4d, 0x8d, 0x42, 0x04, //0x000003ff leaq         $4(%r10), %r8
+	0x48, 0x8d, 0x7b, 0xfc, //0x00000403 leaq         $-4(%rbx), %rdi
+	0x48, 0x83, 0xff, 0x02, //0x00000407 cmpq         $2, %rdi
+	0x0f, 0x83, 0x1f, 0x00, 0x00, 0x00, //0x0000040b jae          LBB0_44
+	0xe9, 0x2e, 0x00, 0x00, 0x00, //0x00000411 jmp          LBB0_45
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000416 .p2align 4, 0x90
+	//0x00000420 LBB0_43
+	0x4d, 0x89, 0xd0, //0x00000420 movq         %r10, %r8
+	0x48, 0x89, 0xdf, //0x00000423 movq         %rbx, %rdi
+	0x48, 0x83, 0xff, 0x02, //0x00000426 cmpq         $2, %rdi
+	0x0f, 0x82, 0x14, 0x00, 0x00, 0x00, //0x0000042a jb           LBB0_45
+	//0x00000430 LBB0_44
+	0x41, 0x0f, 0xb7, 0x17, //0x00000430 movzwl       (%r15), %edx
+	0x66, 0x41, 0x89, 0x10, //0x00000434 movw         %dx, (%r8)
+	0x49, 0x83, 0xc7, 0x02, //0x00000438 addq         $2, %r15
+	0x49, 0x83, 0xc0, 0x02, //0x0000043c addq         $2, %r8
+	0x48, 0x83, 0xc7, 0xfe, //0x00000440 addq         $-2, %rdi
+	//0x00000444 LBB0_45
+	0x48, 0x85, 0xff, //0x00000444 testq        %rdi, %rdi
+	0x0f, 0x84, 0x06, 0x00, 0x00, 0x00, //0x00000447 je           LBB0_47
+	0x41, 0x8a, 0x0f, //0x0000044d movb         (%r15), %cl
+	0x41, 0x88, 0x08, //0x00000450 movb         %cl, (%r8)
+	//0x00000453 LBB0_47
+	0x49, 0x01, 0xda, //0x00000453 addq         %rbx, %r10
+	//0x00000456 LBB0_48
+	0x48, 0xff, 0xc0, //0x00000456 incq         %rax
+	0x49, 0x89, 0xc7, //0x00000459 movq         %rax, %r15
+	0x48, 0x83, 0xfe, 0x01, //0x0000045c cmpq         $1, %rsi
+	0x48, 0x8d, 0x76, 0xff, //0x00000460 leaq         $-1(%rsi), %rsi
+	0x0f, 0x8f, 0x46, 0xfc, 0xff, 0xff, //0x00000464 jg           LBB0_2
+	0xe9, 0x70, 0x00, 0x00, 0x00, //0x0000046a jmp          LBB0_59
+	//0x0000046f LBB0_51
+	0x48, 0x83, 0xfe, 0x03, //0x0000046f cmpq         $3, %rsi
+	0x0f, 0x8c, 0x28, 0x00, 0x00, 0x00, //0x00000473 jl           LBB0_55
+	0x41, 0x80, 0x7f, 0x01, 0x80, //0x00000479 cmpb         $-128, $1(%r15)
+	0x0f, 0x85, 0x1d, 0x00, 0x00, 0x00, //0x0000047e jne          LBB0_55
+	0x41, 0x8a, 0x4f, 0x02, //0x00000484 movb         $2(%r15), %cl
+	0x89, 0xc8, //0x00000488 movl         %ecx, %eax
+	0x24, 0xfe, //0x0000048a andb         $-2, %al
+	0x3c, 0xa8, //0x0000048c cmpb         $-88, %al
+	0x0f, 0x85, 0x0d, 0x00, 0x00, 0x00, //0x0000048e jne          LBB0_55
+	0x49, 0x8d, 0x47, 0x02, //0x00000494 leaq         $2(%r15), %rax
+	0x48, 0x83, 0xc6, 0xfe, //0x00000498 addq         $-2, %rsi
+	0xe9, 0x20, 0xff, 0xff, 0xff, //0x0000049c jmp          LBB0_40
+	//0x000004a1 LBB0_55
+	0x4d, 0x85, 0xc9, //0x000004a1 testq        %r9, %r9
+	0x0f, 0x8e, 0x54, 0x00, 0x00, 0x00, //0x000004a4 jle          LBB0_61
+	0x41, 0xc6, 0x02, 0xe2, //0x000004aa movb         $-30, (%r10)
+	0x49, 0xff, 0xc2, //0x000004ae incq         %r10
+	0x49, 0xff, 0xc9, //0x000004b1 decq         %r9
+	0x4c, 0x89, 0xf8, //0x000004b4 movq         %r15, %rax
+	0xe9, 0x9a, 0xff, 0xff, 0xff, //0x000004b7 jmp          LBB0_48
+	//0x000004bc LBB0_57
+	0x4c, 0x2b, 0x55, 0xc8, //0x000004bc subq         $-56(%rbp), %r10
+	0x49, 0xf7, 0xd4, //0x000004c0 notq         %r12
+	0x4d, 0x01, 0xe2, //0x000004c3 addq         %r12, %r10
+	0x48, 0x8b, 0x45, 0xc0, //0x000004c6 movq         $-64(%rbp), %rax
+	0x4c, 0x89, 0x10, //0x000004ca movq         %r10, (%rax)
+	0x4c, 0x2b, 0x7d, 0xd0, //0x000004cd subq         $-48(%rbp), %r15
+	0x4d, 0x01, 0xe7, //0x000004d1 addq         %r12, %r15
+	0x49, 0xf7, 0xd7, //0x000004d4 notq         %r15
+	0xe9, 0x29, 0x00, 0x00, 0x00, //0x000004d7 jmp          LBB0_62
+	//0x000004dc LBB0_58
+	0x4c, 0x89, 0xf8, //0x000004dc movq         %r15, %rax
+	//0x000004df LBB0_59
+	0x4c, 0x2b, 0x55, 0xc8, //0x000004df subq         $-56(%rbp), %r10
+	0x48, 0x8b, 0x4d, 0xc0, //0x000004e3 movq         $-64(%rbp), %rcx
+	0x4c, 0x89, 0x11, //0x000004e7 movq         %r10, (%rcx)
+	0x48, 0x2b, 0x45, 0xd0, //0x000004ea subq         $-48(%rbp), %rax
+	0xe9, 0x15, 0x00, 0x00, 0x00, //0x000004ee jmp          LBB0_63
+	//0x000004f3 LBB0_60
+	0x4c, 0x2b, 0x55, 0xc8, //0x000004f3 subq         $-56(%rbp), %r10
+	0x48, 0x8b, 0x45, 0xc0, //0x000004f7 movq         $-64(%rbp), %rax
+	0x4c, 0x89, 0x10, //0x000004fb movq         %r10, (%rax)
+	//0x000004fe LBB0_61
+	0x49, 0xf7, 0xd7, //0x000004fe notq         %r15
+	0x4c, 0x03, 0x7d, 0xd0, //0x00000501 addq         $-48(%rbp), %r15
+	//0x00000505 LBB0_62
+	0x4c, 0x89, 0xf8, //0x00000505 movq         %r15, %rax
+	//0x00000508 LBB0_63
+	0x48, 0x83, 0xc4, 0x18, //0x00000508 addq         $24, %rsp
+	0x5b, //0x0000050c popq         %rbx
+	0x41, 0x5c, //0x0000050d popq         %r12
+	0x41, 0x5d, //0x0000050f popq         %r13
+	0x41, 0x5e, //0x00000511 popq         %r14
+	0x41, 0x5f, //0x00000513 popq         %r15
+	0x5d, //0x00000515 popq         %rbp
+	0xc3, //0x00000516 retq         
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000517 .p2align 4, 0x00
+	//0x00000520 __HtmlQuoteTab
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000520 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000530 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000540 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000550 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000560 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000570 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000580 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000590 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000005a0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000005b0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000005c0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000005d0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000005e0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000005f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000600 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000610 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000620 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000630 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000640 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000650 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000660 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000670 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000680 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000690 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000006a0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000006b0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000006c0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000006d0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000006e0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000006f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000700 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000710 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000720 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000730 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000740 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000750 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000760 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000770 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000780 .quad 6
+	0x5c, 0x75, 0x30, 0x30, 0x32, 0x36, 0x00, 0x00, //0x00000788 QUAD $0x000036323030755c  // .asciz 8, '\\u0026\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000790 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000007a0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000007b0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000007c0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000007d0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000007e0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000007f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000800 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000810 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000820 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000830 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000840 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000850 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000860 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000870 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000880 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000890 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000008a0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000008b0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000008c0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000008d0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000008e0 .quad 6
+	0x5c, 0x75, 0x30, 0x30, 0x33, 0x63, 0x00, 0x00, //0x000008e8 QUAD $0x000063333030755c  // .asciz 8, '\\u003c\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000008f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000900 .quad 6
+	0x5c, 0x75, 0x30, 0x30, 0x33, 0x65, 0x00, 0x00, //0x00000908 QUAD $0x000065333030755c  // .asciz 8, '\\u003e\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000910 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000920 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000930 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000940 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000950 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000960 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000970 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000980 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000990 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009a0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009b0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009c0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009d0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009e0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000a00 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000a10 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000a20 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000a30 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000a40 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000a50 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000a60 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000a70 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000a80 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000a90 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000aa0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ab0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ac0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ad0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ae0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000af0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000b00 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000b10 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000b20 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000b30 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000b40 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000b50 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000b60 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000b70 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000b80 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000b90 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ba0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000bb0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000bc0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000bd0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000be0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000bf0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000c00 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000c10 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000c20 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000c30 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000c40 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000c50 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000c60 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000c70 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000c80 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000c90 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ca0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000cb0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000cc0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000cd0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ce0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000cf0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d00 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d10 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d20 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d30 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d40 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d50 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d60 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d70 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d80 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000d90 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000da0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000db0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000dc0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000dd0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000de0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000df0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e00 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e10 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e20 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e30 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e40 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e50 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e60 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e70 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e80 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000e90 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ea0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000eb0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ec0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ed0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ee0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ef0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000f00 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000f10 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000f20 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000f30 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000f40 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000f50 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000f60 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000f70 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000f80 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000f90 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000fa0 .quad 6
+	0x5c, 0x75, 0x32, 0x30, 0x32, 0x38, 0x00, 0x00, //0x00000fa8 QUAD $0x000038323032755c  // .asciz 8, '\\u2028\x00\x00'
+	0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000fb0 .quad 6
+	0x5c, 0x75, 0x32, 0x30, 0x32, 0x39, 0x00, 0x00, //0x00000fb8 QUAD $0x000039323032755c  // .asciz 8, '\\u2029\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000fc0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000fd0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000fe0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000ff0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001000 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001010 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001020 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001030 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001040 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001050 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001060 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001070 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001080 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001090 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000010a0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000010b0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000010c0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000010d0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000010e0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000010f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001100 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001110 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001120 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001130 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001140 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001150 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001160 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001170 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001180 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001190 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000011a0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000011b0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000011c0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000011d0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000011e0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000011f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001200 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001210 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001220 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001230 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001240 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001250 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001260 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001270 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001280 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001290 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000012a0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000012b0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000012c0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000012d0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000012e0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000012f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001300 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001310 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001320 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001330 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001340 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001350 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001360 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001370 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001380 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001390 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000013a0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000013b0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000013c0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000013d0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000013e0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000013f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001400 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001410 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001420 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001430 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001440 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001450 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001460 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001470 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001480 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001490 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000014a0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000014b0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000014c0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000014d0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000014e0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000014f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001500 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00001510 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+}
+ 

vendor/github.com/bytedance/sonic/internal/native/avx/i64toa.go

@@ -0,0 +1,37 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_i64toa func(out unsafe.Pointer, val int64) (ret int)
+
+var S_i64toa uintptr
+
+//go:nosplit
+func i64toa(out *byte, val int64) (ret int) {
+    return F_i64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
+

vendor/github.com/bytedance/sonic/internal/native/avx/i64toa_subr.go

@@ -0,0 +1,47 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__i64toa = 64
+)
+
+const (
+    _stack__i64toa = 8
+)
+
+const (
+    _size__i64toa = 2272
+)
+
+var (
+    _pcsp__i64toa = [][2]uint32{
+        {1, 0},
+        {170, 8},
+        {171, 0},
+        {505, 8},
+        {506, 0},
+        {637, 8},
+        {638, 0},
+        {1101, 8},
+        {1102, 0},
+        {1238, 8},
+        {1239, 0},
+        {1540, 8},
+        {1541, 0},
+        {1901, 8},
+        {1902, 0},
+        {2268, 8},
+        {2270, 0},
+    }
+)
+
+var _cfunc_i64toa = []loader.CFunc{
+    {"_i64toa_entry", 0,  _entry__i64toa, 0, nil},
+    {"_i64toa", _entry__i64toa, _size__i64toa, _stack__i64toa, _pcsp__i64toa},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/i64toa_text_amd64.go

@@ -0,0 +1,639 @@
+// +build amd64
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+var _text_i64toa = []byte{
+	// .p2align 4, 0x00
+	// LCPI0_0
+	0x59, 0x17, 0xb7, 0xd1, 0x00, 0x00, 0x00, 0x00, // .quad 3518437209
+	0x59, 0x17, 0xb7, 0xd1, 0x00, 0x00, 0x00, 0x00, //0x00000008 .quad 3518437209
+	//0x00000010 LCPI0_3
+	0x0a, 0x00, //0x00000010 .word 10
+	0x0a, 0x00, //0x00000012 .word 10
+	0x0a, 0x00, //0x00000014 .word 10
+	0x0a, 0x00, //0x00000016 .word 10
+	0x0a, 0x00, //0x00000018 .word 10
+	0x0a, 0x00, //0x0000001a .word 10
+	0x0a, 0x00, //0x0000001c .word 10
+	0x0a, 0x00, //0x0000001e .word 10
+	//0x00000020 LCPI0_4
+	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, //0x00000020 QUAD $0x3030303030303030; QUAD $0x3030303030303030  // .space 16, '0000000000000000'
+	//0x00000030 .p2align 3, 0x00
+	//0x00000030 LCPI0_1
+	0xc5, 0x20, 0x7b, 0x14, 0x34, 0x33, 0x00, 0x80, //0x00000030 .quad -9223315738079846203
+	//0x00000038 LCPI0_2
+	0x80, 0x00, 0x00, 0x08, 0x00, 0x20, 0x00, 0x80, //0x00000038 .quad -9223336852348469120
+	//0x00000040 .p2align 4, 0x90
+	//0x00000040 _i64toa
+	0x55, //0x00000040 pushq        %rbp
+	0x48, 0x89, 0xe5, //0x00000041 movq         %rsp, %rbp
+	0x48, 0x85, 0xf6, //0x00000044 testq        %rsi, %rsi
+	0x0f, 0x88, 0xaf, 0x00, 0x00, 0x00, //0x00000047 js           LBB0_25
+	0x48, 0x81, 0xfe, 0x0f, 0x27, 0x00, 0x00, //0x0000004d cmpq         $9999, %rsi
+	0x0f, 0x87, 0xf8, 0x00, 0x00, 0x00, //0x00000054 ja           LBB0_9
+	0x0f, 0xb7, 0xc6, //0x0000005a movzwl       %si, %eax
+	0xc1, 0xe8, 0x02, //0x0000005d shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x00000060 imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x00000066 shrl         $17, %eax
+	0x48, 0x8d, 0x14, 0x00, //0x00000069 leaq         (%rax,%rax), %rdx
+	0x6b, 0xc0, 0x64, //0x0000006d imull        $100, %eax, %eax
+	0x89, 0xf1, //0x00000070 movl         %esi, %ecx
+	0x29, 0xc1, //0x00000072 subl         %eax, %ecx
+	0x0f, 0xb7, 0xc1, //0x00000074 movzwl       %cx, %eax
+	0x48, 0x01, 0xc0, //0x00000077 addq         %rax, %rax
+	0x81, 0xfe, 0xe8, 0x03, 0x00, 0x00, //0x0000007a cmpl         $1000, %esi
+	0x0f, 0x82, 0x16, 0x00, 0x00, 0x00, //0x00000080 jb           LBB0_4
+	0x48, 0x8d, 0x0d, 0x93, 0x08, 0x00, 0x00, //0x00000086 leaq         $2195(%rip), %rcx  /* _Digits+0(%rip) */
+	0x8a, 0x0c, 0x0a, //0x0000008d movb         (%rdx,%rcx), %cl
+	0x88, 0x0f, //0x00000090 movb         %cl, (%rdi)
+	0xb9, 0x01, 0x00, 0x00, 0x00, //0x00000092 movl         $1, %ecx
+	0xe9, 0x0b, 0x00, 0x00, 0x00, //0x00000097 jmp          LBB0_5
+	//0x0000009c LBB0_4
+	0x31, 0xc9, //0x0000009c xorl         %ecx, %ecx
+	0x83, 0xfe, 0x64, //0x0000009e cmpl         $100, %esi
+	0x0f, 0x82, 0x45, 0x00, 0x00, 0x00, //0x000000a1 jb           LBB0_6
+	//0x000000a7 LBB0_5
+	0x0f, 0xb7, 0xd2, //0x000000a7 movzwl       %dx, %edx
+	0x48, 0x83, 0xca, 0x01, //0x000000aa orq          $1, %rdx
+	0x48, 0x8d, 0x35, 0x6b, 0x08, 0x00, 0x00, //0x000000ae leaq         $2155(%rip), %rsi  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x32, //0x000000b5 movb         (%rdx,%rsi), %dl
+	0x89, 0xce, //0x000000b8 movl         %ecx, %esi
+	0xff, 0xc1, //0x000000ba incl         %ecx
+	0x88, 0x14, 0x37, //0x000000bc movb         %dl, (%rdi,%rsi)
+	//0x000000bf LBB0_7
+	0x48, 0x8d, 0x15, 0x5a, 0x08, 0x00, 0x00, //0x000000bf leaq         $2138(%rip), %rdx  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x10, //0x000000c6 movb         (%rax,%rdx), %dl
+	0x89, 0xce, //0x000000c9 movl         %ecx, %esi
+	0xff, 0xc1, //0x000000cb incl         %ecx
+	0x88, 0x14, 0x37, //0x000000cd movb         %dl, (%rdi,%rsi)
+	//0x000000d0 LBB0_8
+	0x0f, 0xb7, 0xc0, //0x000000d0 movzwl       %ax, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x000000d3 orq          $1, %rax
+	0x48, 0x8d, 0x15, 0x42, 0x08, 0x00, 0x00, //0x000000d7 leaq         $2114(%rip), %rdx  /* _Digits+0(%rip) */
+	0x8a, 0x04, 0x10, //0x000000de movb         (%rax,%rdx), %al
+	0x89, 0xca, //0x000000e1 movl         %ecx, %edx
+	0xff, 0xc1, //0x000000e3 incl         %ecx
+	0x88, 0x04, 0x17, //0x000000e5 movb         %al, (%rdi,%rdx)
+	0x89, 0xc8, //0x000000e8 movl         %ecx, %eax
+	0x5d, //0x000000ea popq         %rbp
+	0xc3, //0x000000eb retq         
+	//0x000000ec LBB0_6
+	0x31, 0xc9, //0x000000ec xorl         %ecx, %ecx
+	0x83, 0xfe, 0x0a, //0x000000ee cmpl         $10, %esi
+	0x0f, 0x83, 0xc8, 0xff, 0xff, 0xff, //0x000000f1 jae          LBB0_7
+	0xe9, 0xd4, 0xff, 0xff, 0xff, //0x000000f7 jmp          LBB0_8
+	//0x000000fc LBB0_25
+	0xc6, 0x07, 0x2d, //0x000000fc movb         $45, (%rdi)
+	0x48, 0xf7, 0xde, //0x000000ff negq         %rsi
+	0x48, 0x81, 0xfe, 0x0f, 0x27, 0x00, 0x00, //0x00000102 cmpq         $9999, %rsi
+	0x0f, 0x87, 0xd3, 0x01, 0x00, 0x00, //0x00000109 ja           LBB0_33
+	0x0f, 0xb7, 0xc6, //0x0000010f movzwl       %si, %eax
+	0xc1, 0xe8, 0x02, //0x00000112 shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x00000115 imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x0000011b shrl         $17, %eax
+	0x48, 0x8d, 0x14, 0x00, //0x0000011e leaq         (%rax,%rax), %rdx
+	0x6b, 0xc0, 0x64, //0x00000122 imull        $100, %eax, %eax
+	0x89, 0xf1, //0x00000125 movl         %esi, %ecx
+	0x29, 0xc1, //0x00000127 subl         %eax, %ecx
+	0x0f, 0xb7, 0xc1, //0x00000129 movzwl       %cx, %eax
+	0x48, 0x01, 0xc0, //0x0000012c addq         %rax, %rax
+	0x81, 0xfe, 0xe8, 0x03, 0x00, 0x00, //0x0000012f cmpl         $1000, %esi
+	0x0f, 0x82, 0xab, 0x00, 0x00, 0x00, //0x00000135 jb           LBB0_28
+	0x48, 0x8d, 0x0d, 0xde, 0x07, 0x00, 0x00, //0x0000013b leaq         $2014(%rip), %rcx  /* _Digits+0(%rip) */
+	0x8a, 0x0c, 0x0a, //0x00000142 movb         (%rdx,%rcx), %cl
+	0x88, 0x4f, 0x01, //0x00000145 movb         %cl, $1(%rdi)
+	0xb9, 0x01, 0x00, 0x00, 0x00, //0x00000148 movl         $1, %ecx
+	0xe9, 0x9f, 0x00, 0x00, 0x00, //0x0000014d jmp          LBB0_29
+	//0x00000152 LBB0_9
+	0x48, 0x81, 0xfe, 0xff, 0xe0, 0xf5, 0x05, //0x00000152 cmpq         $99999999, %rsi
+	0x0f, 0x87, 0x18, 0x02, 0x00, 0x00, //0x00000159 ja           LBB0_17
+	0x89, 0xf0, //0x0000015f movl         %esi, %eax
+	0xba, 0x59, 0x17, 0xb7, 0xd1, //0x00000161 movl         $3518437209, %edx
+	0x48, 0x0f, 0xaf, 0xd0, //0x00000166 imulq        %rax, %rdx
+	0x48, 0xc1, 0xea, 0x2d, //0x0000016a shrq         $45, %rdx
+	0x44, 0x69, 0xc2, 0x10, 0x27, 0x00, 0x00, //0x0000016e imull        $10000, %edx, %r8d
+	0x89, 0xf1, //0x00000175 movl         %esi, %ecx
+	0x44, 0x29, 0xc1, //0x00000177 subl         %r8d, %ecx
+	0x4c, 0x69, 0xd0, 0x83, 0xde, 0x1b, 0x43, //0x0000017a imulq        $1125899907, %rax, %r10
+	0x49, 0xc1, 0xea, 0x31, //0x00000181 shrq         $49, %r10
+	0x41, 0x83, 0xe2, 0xfe, //0x00000185 andl         $-2, %r10d
+	0x0f, 0xb7, 0xc2, //0x00000189 movzwl       %dx, %eax
+	0xc1, 0xe8, 0x02, //0x0000018c shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x0000018f imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x00000195 shrl         $17, %eax
+	0x6b, 0xc0, 0x64, //0x00000198 imull        $100, %eax, %eax
+	0x29, 0xc2, //0x0000019b subl         %eax, %edx
+	0x44, 0x0f, 0xb7, 0xca, //0x0000019d movzwl       %dx, %r9d
+	0x4d, 0x01, 0xc9, //0x000001a1 addq         %r9, %r9
+	0x0f, 0xb7, 0xc1, //0x000001a4 movzwl       %cx, %eax
+	0xc1, 0xe8, 0x02, //0x000001a7 shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x000001aa imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x000001b0 shrl         $17, %eax
+	0x4c, 0x8d, 0x04, 0x00, //0x000001b3 leaq         (%rax,%rax), %r8
+	0x6b, 0xc0, 0x64, //0x000001b7 imull        $100, %eax, %eax
+	0x29, 0xc1, //0x000001ba subl         %eax, %ecx
+	0x44, 0x0f, 0xb7, 0xd9, //0x000001bc movzwl       %cx, %r11d
+	0x4d, 0x01, 0xdb, //0x000001c0 addq         %r11, %r11
+	0x81, 0xfe, 0x80, 0x96, 0x98, 0x00, //0x000001c3 cmpl         $10000000, %esi
+	0x0f, 0x82, 0x6c, 0x00, 0x00, 0x00, //0x000001c9 jb           LBB0_12
+	0x48, 0x8d, 0x05, 0x4a, 0x07, 0x00, 0x00, //0x000001cf leaq         $1866(%rip), %rax  /* _Digits+0(%rip) */
+	0x41, 0x8a, 0x04, 0x02, //0x000001d6 movb         (%r10,%rax), %al
+	0x88, 0x07, //0x000001da movb         %al, (%rdi)
+	0xb9, 0x01, 0x00, 0x00, 0x00, //0x000001dc movl         $1, %ecx
+	0xe9, 0x63, 0x00, 0x00, 0x00, //0x000001e1 jmp          LBB0_13
+	//0x000001e6 LBB0_28
+	0x31, 0xc9, //0x000001e6 xorl         %ecx, %ecx
+	0x83, 0xfe, 0x64, //0x000001e8 cmpl         $100, %esi
+	0x0f, 0x82, 0xce, 0x00, 0x00, 0x00, //0x000001eb jb           LBB0_30
+	//0x000001f1 LBB0_29
+	0x0f, 0xb7, 0xd2, //0x000001f1 movzwl       %dx, %edx
+	0x48, 0x83, 0xca, 0x01, //0x000001f4 orq          $1, %rdx
+	0x48, 0x8d, 0x35, 0x21, 0x07, 0x00, 0x00, //0x000001f8 leaq         $1825(%rip), %rsi  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x32, //0x000001ff movb         (%rdx,%rsi), %dl
+	0x89, 0xce, //0x00000202 movl         %ecx, %esi
+	0xff, 0xc1, //0x00000204 incl         %ecx
+	0x88, 0x54, 0x37, 0x01, //0x00000206 movb         %dl, $1(%rdi,%rsi)
+	//0x0000020a LBB0_31
+	0x48, 0x8d, 0x15, 0x0f, 0x07, 0x00, 0x00, //0x0000020a leaq         $1807(%rip), %rdx  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x10, //0x00000211 movb         (%rax,%rdx), %dl
+	0x89, 0xce, //0x00000214 movl         %ecx, %esi
+	0xff, 0xc1, //0x00000216 incl         %ecx
+	0x88, 0x54, 0x37, 0x01, //0x00000218 movb         %dl, $1(%rdi,%rsi)
+	//0x0000021c LBB0_32
+	0x0f, 0xb7, 0xc0, //0x0000021c movzwl       %ax, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x0000021f orq          $1, %rax
+	0x48, 0x8d, 0x15, 0xf6, 0x06, 0x00, 0x00, //0x00000223 leaq         $1782(%rip), %rdx  /* _Digits+0(%rip) */
+	0x8a, 0x04, 0x10, //0x0000022a movb         (%rax,%rdx), %al
+	0x89, 0xca, //0x0000022d movl         %ecx, %edx
+	0xff, 0xc1, //0x0000022f incl         %ecx
+	0x88, 0x44, 0x17, 0x01, //0x00000231 movb         %al, $1(%rdi,%rdx)
+	0xff, 0xc1, //0x00000235 incl         %ecx
+	0x89, 0xc8, //0x00000237 movl         %ecx, %eax
+	0x5d, //0x00000239 popq         %rbp
+	0xc3, //0x0000023a retq         
+	//0x0000023b LBB0_12
+	0x31, 0xc9, //0x0000023b xorl         %ecx, %ecx
+	0x81, 0xfe, 0x40, 0x42, 0x0f, 0x00, //0x0000023d cmpl         $1000000, %esi
+	0x0f, 0x82, 0x86, 0x00, 0x00, 0x00, //0x00000243 jb           LBB0_14
+	//0x00000249 LBB0_13
+	0x44, 0x89, 0xd0, //0x00000249 movl         %r10d, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x0000024c orq          $1, %rax
+	0x48, 0x8d, 0x35, 0xc9, 0x06, 0x00, 0x00, //0x00000250 leaq         $1737(%rip), %rsi  /* _Digits+0(%rip) */
+	0x8a, 0x04, 0x30, //0x00000257 movb         (%rax,%rsi), %al
+	0x89, 0xce, //0x0000025a movl         %ecx, %esi
+	0xff, 0xc1, //0x0000025c incl         %ecx
+	0x88, 0x04, 0x37, //0x0000025e movb         %al, (%rdi,%rsi)
+	//0x00000261 LBB0_15
+	0x48, 0x8d, 0x05, 0xb8, 0x06, 0x00, 0x00, //0x00000261 leaq         $1720(%rip), %rax  /* _Digits+0(%rip) */
+	0x41, 0x8a, 0x04, 0x01, //0x00000268 movb         (%r9,%rax), %al
+	0x89, 0xce, //0x0000026c movl         %ecx, %esi
+	0xff, 0xc1, //0x0000026e incl         %ecx
+	0x88, 0x04, 0x37, //0x00000270 movb         %al, (%rdi,%rsi)
+	//0x00000273 LBB0_16
+	0x41, 0x0f, 0xb7, 0xc1, //0x00000273 movzwl       %r9w, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x00000277 orq          $1, %rax
+	0x48, 0x8d, 0x35, 0x9e, 0x06, 0x00, 0x00, //0x0000027b leaq         $1694(%rip), %rsi  /* _Digits+0(%rip) */
+	0x8a, 0x04, 0x30, //0x00000282 movb         (%rax,%rsi), %al
+	0x89, 0xca, //0x00000285 movl         %ecx, %edx
+	0x88, 0x04, 0x3a, //0x00000287 movb         %al, (%rdx,%rdi)
+	0x41, 0x8a, 0x04, 0x30, //0x0000028a movb         (%r8,%rsi), %al
+	0x88, 0x44, 0x3a, 0x01, //0x0000028e movb         %al, $1(%rdx,%rdi)
+	0x41, 0x0f, 0xb7, 0xc0, //0x00000292 movzwl       %r8w, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x00000296 orq          $1, %rax
+	0x8a, 0x04, 0x30, //0x0000029a movb         (%rax,%rsi), %al
+	0x88, 0x44, 0x3a, 0x02, //0x0000029d movb         %al, $2(%rdx,%rdi)
+	0x41, 0x8a, 0x04, 0x33, //0x000002a1 movb         (%r11,%rsi), %al
+	0x88, 0x44, 0x3a, 0x03, //0x000002a5 movb         %al, $3(%rdx,%rdi)
+	0x41, 0x0f, 0xb7, 0xc3, //0x000002a9 movzwl       %r11w, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x000002ad orq          $1, %rax
+	0x8a, 0x04, 0x30, //0x000002b1 movb         (%rax,%rsi), %al
+	0x83, 0xc1, 0x05, //0x000002b4 addl         $5, %ecx
+	0x88, 0x44, 0x3a, 0x04, //0x000002b7 movb         %al, $4(%rdx,%rdi)
+	0x89, 0xc8, //0x000002bb movl         %ecx, %eax
+	0x5d, //0x000002bd popq         %rbp
+	0xc3, //0x000002be retq         
+	//0x000002bf LBB0_30
+	0x31, 0xc9, //0x000002bf xorl         %ecx, %ecx
+	0x83, 0xfe, 0x0a, //0x000002c1 cmpl         $10, %esi
+	0x0f, 0x83, 0x40, 0xff, 0xff, 0xff, //0x000002c4 jae          LBB0_31
+	0xe9, 0x4d, 0xff, 0xff, 0xff, //0x000002ca jmp          LBB0_32
+	//0x000002cf LBB0_14
+	0x31, 0xc9, //0x000002cf xorl         %ecx, %ecx
+	0x81, 0xfe, 0xa0, 0x86, 0x01, 0x00, //0x000002d1 cmpl         $100000, %esi
+	0x0f, 0x83, 0x84, 0xff, 0xff, 0xff, //0x000002d7 jae          LBB0_15
+	0xe9, 0x91, 0xff, 0xff, 0xff, //0x000002dd jmp          LBB0_16
+	//0x000002e2 LBB0_33
+	0x48, 0x81, 0xfe, 0xff, 0xe0, 0xf5, 0x05, //0x000002e2 cmpq         $99999999, %rsi
+	0x0f, 0x87, 0x3c, 0x02, 0x00, 0x00, //0x000002e9 ja           LBB0_41
+	0x89, 0xf0, //0x000002ef movl         %esi, %eax
+	0xba, 0x59, 0x17, 0xb7, 0xd1, //0x000002f1 movl         $3518437209, %edx
+	0x48, 0x0f, 0xaf, 0xd0, //0x000002f6 imulq        %rax, %rdx
+	0x48, 0xc1, 0xea, 0x2d, //0x000002fa shrq         $45, %rdx
+	0x44, 0x69, 0xc2, 0x10, 0x27, 0x00, 0x00, //0x000002fe imull        $10000, %edx, %r8d
+	0x89, 0xf1, //0x00000305 movl         %esi, %ecx
+	0x44, 0x29, 0xc1, //0x00000307 subl         %r8d, %ecx
+	0x4c, 0x69, 0xd0, 0x83, 0xde, 0x1b, 0x43, //0x0000030a imulq        $1125899907, %rax, %r10
+	0x49, 0xc1, 0xea, 0x31, //0x00000311 shrq         $49, %r10
+	0x41, 0x83, 0xe2, 0xfe, //0x00000315 andl         $-2, %r10d
+	0x0f, 0xb7, 0xc2, //0x00000319 movzwl       %dx, %eax
+	0xc1, 0xe8, 0x02, //0x0000031c shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x0000031f imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x00000325 shrl         $17, %eax
+	0x6b, 0xc0, 0x64, //0x00000328 imull        $100, %eax, %eax
+	0x29, 0xc2, //0x0000032b subl         %eax, %edx
+	0x44, 0x0f, 0xb7, 0xca, //0x0000032d movzwl       %dx, %r9d
+	0x4d, 0x01, 0xc9, //0x00000331 addq         %r9, %r9
+	0x0f, 0xb7, 0xc1, //0x00000334 movzwl       %cx, %eax
+	0xc1, 0xe8, 0x02, //0x00000337 shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x0000033a imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x00000340 shrl         $17, %eax
+	0x4c, 0x8d, 0x04, 0x00, //0x00000343 leaq         (%rax,%rax), %r8
+	0x6b, 0xc0, 0x64, //0x00000347 imull        $100, %eax, %eax
+	0x29, 0xc1, //0x0000034a subl         %eax, %ecx
+	0x44, 0x0f, 0xb7, 0xd9, //0x0000034c movzwl       %cx, %r11d
+	0x4d, 0x01, 0xdb, //0x00000350 addq         %r11, %r11
+	0x81, 0xfe, 0x80, 0x96, 0x98, 0x00, //0x00000353 cmpl         $10000000, %esi
+	0x0f, 0x82, 0x30, 0x01, 0x00, 0x00, //0x00000359 jb           LBB0_36
+	0x48, 0x8d, 0x05, 0xba, 0x05, 0x00, 0x00, //0x0000035f leaq         $1466(%rip), %rax  /* _Digits+0(%rip) */
+	0x41, 0x8a, 0x04, 0x02, //0x00000366 movb         (%r10,%rax), %al
+	0x88, 0x47, 0x01, //0x0000036a movb         %al, $1(%rdi)
+	0xb9, 0x01, 0x00, 0x00, 0x00, //0x0000036d movl         $1, %ecx
+	0xe9, 0x26, 0x01, 0x00, 0x00, //0x00000372 jmp          LBB0_37
+	//0x00000377 LBB0_17
+	0x48, 0xb9, 0x00, 0x00, 0xc1, 0x6f, 0xf2, 0x86, 0x23, 0x00, //0x00000377 movabsq      $10000000000000000, %rcx
+	0x48, 0x39, 0xce, //0x00000381 cmpq         %rcx, %rsi
+	0x0f, 0x83, 0xbc, 0x02, 0x00, 0x00, //0x00000384 jae          LBB0_19
+	0x48, 0xb9, 0xfd, 0xce, 0x61, 0x84, 0x11, 0x77, 0xcc, 0xab, //0x0000038a movabsq      $-6067343680855748867, %rcx
+	0x48, 0x89, 0xf0, //0x00000394 movq         %rsi, %rax
+	0x48, 0xf7, 0xe1, //0x00000397 mulq         %rcx
+	0x48, 0xc1, 0xea, 0x1a, //0x0000039a shrq         $26, %rdx
+	0x69, 0xc2, 0x00, 0xe1, 0xf5, 0x05, //0x0000039e imull        $100000000, %edx, %eax
+	0x29, 0xc6, //0x000003a4 subl         %eax, %esi
+	0xc5, 0xf9, 0x6e, 0xc2, //0x000003a6 vmovd        %edx, %xmm0
+	0xc5, 0xfa, 0x6f, 0x0d, 0x4e, 0xfc, 0xff, 0xff, //0x000003aa vmovdqu      $-946(%rip), %xmm1  /* LCPI0_0+0(%rip) */
+	0xc5, 0xf9, 0xf4, 0xd1, //0x000003b2 vpmuludq     %xmm1, %xmm0, %xmm2
+	0xc5, 0xe9, 0x73, 0xd2, 0x2d, //0x000003b6 vpsrlq       $45, %xmm2, %xmm2
+	0xb8, 0x10, 0x27, 0x00, 0x00, //0x000003bb movl         $10000, %eax
+	0xc4, 0xe1, 0xf9, 0x6e, 0xd8, //0x000003c0 vmovq        %rax, %xmm3
+	0xc5, 0xe9, 0xf4, 0xe3, //0x000003c5 vpmuludq     %xmm3, %xmm2, %xmm4
+	0xc5, 0xf9, 0xfa, 0xc4, //0x000003c9 vpsubd       %xmm4, %xmm0, %xmm0
+	0xc5, 0xe9, 0x61, 0xc0, //0x000003cd vpunpcklwd   %xmm0, %xmm2, %xmm0
+	0xc5, 0xf9, 0x73, 0xf0, 0x02, //0x000003d1 vpsllq       $2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x70, 0xc0, 0x50, //0x000003d6 vpshuflw     $80, %xmm0, %xmm0
+	0xc5, 0xf9, 0x70, 0xc0, 0x50, //0x000003db vpshufd      $80, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x15, 0x48, 0xfc, 0xff, 0xff, //0x000003e0 vmovddup     $-952(%rip), %xmm2  /* LCPI0_1+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc2, //0x000003e8 vpmulhuw     %xmm2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x25, 0x44, 0xfc, 0xff, 0xff, //0x000003ec vmovddup     $-956(%rip), %xmm4  /* LCPI0_2+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc4, //0x000003f4 vpmulhuw     %xmm4, %xmm0, %xmm0
+	0xc5, 0xfa, 0x6f, 0x2d, 0x10, 0xfc, 0xff, 0xff, //0x000003f8 vmovdqu      $-1008(%rip), %xmm5  /* LCPI0_3+0(%rip) */
+	0xc5, 0xf9, 0xd5, 0xf5, //0x00000400 vpmullw      %xmm5, %xmm0, %xmm6
+	0xc5, 0xc9, 0x73, 0xf6, 0x10, //0x00000404 vpsllq       $16, %xmm6, %xmm6
+	0xc5, 0xf9, 0xf9, 0xc6, //0x00000409 vpsubw       %xmm6, %xmm0, %xmm0
+	0xc5, 0xf9, 0x6e, 0xf6, //0x0000040d vmovd        %esi, %xmm6
+	0xc5, 0xc9, 0xf4, 0xc9, //0x00000411 vpmuludq     %xmm1, %xmm6, %xmm1
+	0xc5, 0xf1, 0x73, 0xd1, 0x2d, //0x00000415 vpsrlq       $45, %xmm1, %xmm1
+	0xc5, 0xf1, 0xf4, 0xdb, //0x0000041a vpmuludq     %xmm3, %xmm1, %xmm3
+	0xc5, 0xc9, 0xfa, 0xdb, //0x0000041e vpsubd       %xmm3, %xmm6, %xmm3
+	0xc5, 0xf1, 0x61, 0xcb, //0x00000422 vpunpcklwd   %xmm3, %xmm1, %xmm1
+	0xc5, 0xf1, 0x73, 0xf1, 0x02, //0x00000426 vpsllq       $2, %xmm1, %xmm1
+	0xc5, 0xfb, 0x70, 0xc9, 0x50, //0x0000042b vpshuflw     $80, %xmm1, %xmm1
+	0xc5, 0xf9, 0x70, 0xc9, 0x50, //0x00000430 vpshufd      $80, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xca, //0x00000435 vpmulhuw     %xmm2, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xcc, //0x00000439 vpmulhuw     %xmm4, %xmm1, %xmm1
+	0xc5, 0xf1, 0xd5, 0xd5, //0x0000043d vpmullw      %xmm5, %xmm1, %xmm2
+	0xc5, 0xe9, 0x73, 0xf2, 0x10, //0x00000441 vpsllq       $16, %xmm2, %xmm2
+	0xc5, 0xf1, 0xf9, 0xca, //0x00000446 vpsubw       %xmm2, %xmm1, %xmm1
+	0xc5, 0xf9, 0x67, 0xc1, //0x0000044a vpackuswb    %xmm1, %xmm0, %xmm0
+	0xc5, 0xf9, 0xfc, 0x0d, 0xca, 0xfb, 0xff, 0xff, //0x0000044e vpaddb       $-1078(%rip), %xmm0, %xmm1  /* LCPI0_4+0(%rip) */
+	0xc5, 0xe9, 0xef, 0xd2, //0x00000456 vpxor        %xmm2, %xmm2, %xmm2
+	0xc5, 0xf9, 0x74, 0xc2, //0x0000045a vpcmpeqb     %xmm2, %xmm0, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc0, //0x0000045e vpmovmskb    %xmm0, %eax
+	0x0d, 0x00, 0x80, 0x00, 0x00, //0x00000462 orl          $32768, %eax
+	0x35, 0xff, 0x7f, 0xff, 0xff, //0x00000467 xorl         $-32769, %eax
+	0x0f, 0xbc, 0xc0, //0x0000046c bsfl         %eax, %eax
+	0xb9, 0x10, 0x00, 0x00, 0x00, //0x0000046f movl         $16, %ecx
+	0x29, 0xc1, //0x00000474 subl         %eax, %ecx
+	0x48, 0xc1, 0xe0, 0x04, //0x00000476 shlq         $4, %rax
+	0x48, 0x8d, 0x15, 0x6f, 0x05, 0x00, 0x00, //0x0000047a leaq         $1391(%rip), %rdx  /* _VecShiftShuffles+0(%rip) */
+	0xc4, 0xe2, 0x71, 0x00, 0x04, 0x10, //0x00000481 vpshufb      (%rax,%rdx), %xmm1, %xmm0
+	0xc5, 0xfa, 0x7f, 0x07, //0x00000487 vmovdqu      %xmm0, (%rdi)
+	0x89, 0xc8, //0x0000048b movl         %ecx, %eax
+	0x5d, //0x0000048d popq         %rbp
+	0xc3, //0x0000048e retq         
+	//0x0000048f LBB0_36
+	0x31, 0xc9, //0x0000048f xorl         %ecx, %ecx
+	0x81, 0xfe, 0x40, 0x42, 0x0f, 0x00, //0x00000491 cmpl         $1000000, %esi
+	0x0f, 0x82, 0x7b, 0x00, 0x00, 0x00, //0x00000497 jb           LBB0_38
+	//0x0000049d LBB0_37
+	0x44, 0x89, 0xd0, //0x0000049d movl         %r10d, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x000004a0 orq          $1, %rax
+	0x48, 0x8d, 0x35, 0x75, 0x04, 0x00, 0x00, //0x000004a4 leaq         $1141(%rip), %rsi  /* _Digits+0(%rip) */
+	0x8a, 0x04, 0x30, //0x000004ab movb         (%rax,%rsi), %al
+	0x89, 0xce, //0x000004ae movl         %ecx, %esi
+	0xff, 0xc1, //0x000004b0 incl         %ecx
+	0x88, 0x44, 0x37, 0x01, //0x000004b2 movb         %al, $1(%rdi,%rsi)
+	//0x000004b6 LBB0_39
+	0x48, 0x8d, 0x05, 0x63, 0x04, 0x00, 0x00, //0x000004b6 leaq         $1123(%rip), %rax  /* _Digits+0(%rip) */
+	0x41, 0x8a, 0x04, 0x01, //0x000004bd movb         (%r9,%rax), %al
+	0x89, 0xce, //0x000004c1 movl         %ecx, %esi
+	0xff, 0xc1, //0x000004c3 incl         %ecx
+	0x88, 0x44, 0x37, 0x01, //0x000004c5 movb         %al, $1(%rdi,%rsi)
+	//0x000004c9 LBB0_40
+	0x41, 0x0f, 0xb7, 0xc1, //0x000004c9 movzwl       %r9w, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x000004cd orq          $1, %rax
+	0x48, 0x8d, 0x35, 0x48, 0x04, 0x00, 0x00, //0x000004d1 leaq         $1096(%rip), %rsi  /* _Digits+0(%rip) */
+	0x8a, 0x04, 0x30, //0x000004d8 movb         (%rax,%rsi), %al
+	0x89, 0xca, //0x000004db movl         %ecx, %edx
+	0x88, 0x44, 0x17, 0x01, //0x000004dd movb         %al, $1(%rdi,%rdx)
+	0x41, 0x8a, 0x04, 0x30, //0x000004e1 movb         (%r8,%rsi), %al
+	0x88, 0x44, 0x17, 0x02, //0x000004e5 movb         %al, $2(%rdi,%rdx)
+	0x41, 0x0f, 0xb7, 0xc0, //0x000004e9 movzwl       %r8w, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x000004ed orq          $1, %rax
+	0x8a, 0x04, 0x30, //0x000004f1 movb         (%rax,%rsi), %al
+	0x88, 0x44, 0x17, 0x03, //0x000004f4 movb         %al, $3(%rdi,%rdx)
+	0x41, 0x8a, 0x04, 0x33, //0x000004f8 movb         (%r11,%rsi), %al
+	0x88, 0x44, 0x17, 0x04, //0x000004fc movb         %al, $4(%rdi,%rdx)
+	0x41, 0x0f, 0xb7, 0xc3, //0x00000500 movzwl       %r11w, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x00000504 orq          $1, %rax
+	0x8a, 0x04, 0x30, //0x00000508 movb         (%rax,%rsi), %al
+	0x83, 0xc1, 0x05, //0x0000050b addl         $5, %ecx
+	0x88, 0x44, 0x17, 0x05, //0x0000050e movb         %al, $5(%rdi,%rdx)
+	0xff, 0xc1, //0x00000512 incl         %ecx
+	0x89, 0xc8, //0x00000514 movl         %ecx, %eax
+	0x5d, //0x00000516 popq         %rbp
+	0xc3, //0x00000517 retq         
+	//0x00000518 LBB0_38
+	0x31, 0xc9, //0x00000518 xorl         %ecx, %ecx
+	0x81, 0xfe, 0xa0, 0x86, 0x01, 0x00, //0x0000051a cmpl         $100000, %esi
+	0x0f, 0x83, 0x90, 0xff, 0xff, 0xff, //0x00000520 jae          LBB0_39
+	0xe9, 0x9e, 0xff, 0xff, 0xff, //0x00000526 jmp          LBB0_40
+	//0x0000052b LBB0_41
+	0x48, 0xb9, 0x00, 0x00, 0xc1, 0x6f, 0xf2, 0x86, 0x23, 0x00, //0x0000052b movabsq      $10000000000000000, %rcx
+	0x48, 0x39, 0xce, //0x00000535 cmpq         %rcx, %rsi
+	0x0f, 0x83, 0x71, 0x02, 0x00, 0x00, //0x00000538 jae          LBB0_43
+	0x48, 0xb9, 0xfd, 0xce, 0x61, 0x84, 0x11, 0x77, 0xcc, 0xab, //0x0000053e movabsq      $-6067343680855748867, %rcx
+	0x48, 0x89, 0xf0, //0x00000548 movq         %rsi, %rax
+	0x48, 0xf7, 0xe1, //0x0000054b mulq         %rcx
+	0x48, 0xc1, 0xea, 0x1a, //0x0000054e shrq         $26, %rdx
+	0x69, 0xc2, 0x00, 0xe1, 0xf5, 0x05, //0x00000552 imull        $100000000, %edx, %eax
+	0x29, 0xc6, //0x00000558 subl         %eax, %esi
+	0xc5, 0xf9, 0x6e, 0xc2, //0x0000055a vmovd        %edx, %xmm0
+	0xc5, 0xfa, 0x6f, 0x0d, 0x9a, 0xfa, 0xff, 0xff, //0x0000055e vmovdqu      $-1382(%rip), %xmm1  /* LCPI0_0+0(%rip) */
+	0xc5, 0xf9, 0xf4, 0xd1, //0x00000566 vpmuludq     %xmm1, %xmm0, %xmm2
+	0xc5, 0xe9, 0x73, 0xd2, 0x2d, //0x0000056a vpsrlq       $45, %xmm2, %xmm2
+	0xb8, 0x10, 0x27, 0x00, 0x00, //0x0000056f movl         $10000, %eax
+	0xc4, 0xe1, 0xf9, 0x6e, 0xd8, //0x00000574 vmovq        %rax, %xmm3
+	0xc5, 0xe9, 0xf4, 0xe3, //0x00000579 vpmuludq     %xmm3, %xmm2, %xmm4
+	0xc5, 0xf9, 0xfa, 0xc4, //0x0000057d vpsubd       %xmm4, %xmm0, %xmm0
+	0xc5, 0xe9, 0x61, 0xc0, //0x00000581 vpunpcklwd   %xmm0, %xmm2, %xmm0
+	0xc5, 0xf9, 0x73, 0xf0, 0x02, //0x00000585 vpsllq       $2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x70, 0xc0, 0x50, //0x0000058a vpshuflw     $80, %xmm0, %xmm0
+	0xc5, 0xf9, 0x70, 0xc0, 0x50, //0x0000058f vpshufd      $80, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x15, 0x94, 0xfa, 0xff, 0xff, //0x00000594 vmovddup     $-1388(%rip), %xmm2  /* LCPI0_1+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc2, //0x0000059c vpmulhuw     %xmm2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x25, 0x90, 0xfa, 0xff, 0xff, //0x000005a0 vmovddup     $-1392(%rip), %xmm4  /* LCPI0_2+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc4, //0x000005a8 vpmulhuw     %xmm4, %xmm0, %xmm0
+	0xc5, 0xfa, 0x6f, 0x2d, 0x5c, 0xfa, 0xff, 0xff, //0x000005ac vmovdqu      $-1444(%rip), %xmm5  /* LCPI0_3+0(%rip) */
+	0xc5, 0xf9, 0xd5, 0xf5, //0x000005b4 vpmullw      %xmm5, %xmm0, %xmm6
+	0xc5, 0xc9, 0x73, 0xf6, 0x10, //0x000005b8 vpsllq       $16, %xmm6, %xmm6
+	0xc5, 0xf9, 0xf9, 0xc6, //0x000005bd vpsubw       %xmm6, %xmm0, %xmm0
+	0xc5, 0xf9, 0x6e, 0xf6, //0x000005c1 vmovd        %esi, %xmm6
+	0xc5, 0xc9, 0xf4, 0xc9, //0x000005c5 vpmuludq     %xmm1, %xmm6, %xmm1
+	0xc5, 0xf1, 0x73, 0xd1, 0x2d, //0x000005c9 vpsrlq       $45, %xmm1, %xmm1
+	0xc5, 0xf1, 0xf4, 0xdb, //0x000005ce vpmuludq     %xmm3, %xmm1, %xmm3
+	0xc5, 0xc9, 0xfa, 0xdb, //0x000005d2 vpsubd       %xmm3, %xmm6, %xmm3
+	0xc5, 0xf1, 0x61, 0xcb, //0x000005d6 vpunpcklwd   %xmm3, %xmm1, %xmm1
+	0xc5, 0xf1, 0x73, 0xf1, 0x02, //0x000005da vpsllq       $2, %xmm1, %xmm1
+	0xc5, 0xfb, 0x70, 0xc9, 0x50, //0x000005df vpshuflw     $80, %xmm1, %xmm1
+	0xc5, 0xf9, 0x70, 0xc9, 0x50, //0x000005e4 vpshufd      $80, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xca, //0x000005e9 vpmulhuw     %xmm2, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xcc, //0x000005ed vpmulhuw     %xmm4, %xmm1, %xmm1
+	0xc5, 0xf1, 0xd5, 0xd5, //0x000005f1 vpmullw      %xmm5, %xmm1, %xmm2
+	0xc5, 0xe9, 0x73, 0xf2, 0x10, //0x000005f5 vpsllq       $16, %xmm2, %xmm2
+	0xc5, 0xf1, 0xf9, 0xca, //0x000005fa vpsubw       %xmm2, %xmm1, %xmm1
+	0xc5, 0xf9, 0x67, 0xc1, //0x000005fe vpackuswb    %xmm1, %xmm0, %xmm0
+	0xc5, 0xf9, 0xfc, 0x0d, 0x16, 0xfa, 0xff, 0xff, //0x00000602 vpaddb       $-1514(%rip), %xmm0, %xmm1  /* LCPI0_4+0(%rip) */
+	0xc5, 0xe9, 0xef, 0xd2, //0x0000060a vpxor        %xmm2, %xmm2, %xmm2
+	0xc5, 0xf9, 0x74, 0xc2, //0x0000060e vpcmpeqb     %xmm2, %xmm0, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc0, //0x00000612 vpmovmskb    %xmm0, %eax
+	0x0d, 0x00, 0x80, 0x00, 0x00, //0x00000616 orl          $32768, %eax
+	0x35, 0xff, 0x7f, 0xff, 0xff, //0x0000061b xorl         $-32769, %eax
+	0x0f, 0xbc, 0xc0, //0x00000620 bsfl         %eax, %eax
+	0xb9, 0x10, 0x00, 0x00, 0x00, //0x00000623 movl         $16, %ecx
+	0x29, 0xc1, //0x00000628 subl         %eax, %ecx
+	0x48, 0xc1, 0xe0, 0x04, //0x0000062a shlq         $4, %rax
+	0x48, 0x8d, 0x15, 0xbb, 0x03, 0x00, 0x00, //0x0000062e leaq         $955(%rip), %rdx  /* _VecShiftShuffles+0(%rip) */
+	0xc4, 0xe2, 0x71, 0x00, 0x04, 0x10, //0x00000635 vpshufb      (%rax,%rdx), %xmm1, %xmm0
+	0xc5, 0xfa, 0x7f, 0x47, 0x01, //0x0000063b vmovdqu      %xmm0, $1(%rdi)
+	0xff, 0xc1, //0x00000640 incl         %ecx
+	0x89, 0xc8, //0x00000642 movl         %ecx, %eax
+	0x5d, //0x00000644 popq         %rbp
+	0xc3, //0x00000645 retq         
+	//0x00000646 LBB0_19
+	0x48, 0xba, 0x57, 0x78, 0x13, 0xb1, 0x2f, 0x65, 0xa5, 0x39, //0x00000646 movabsq      $4153837486827862103, %rdx
+	0x48, 0x89, 0xf0, //0x00000650 movq         %rsi, %rax
+	0x48, 0xf7, 0xe2, //0x00000653 mulq         %rdx
+	0x48, 0xc1, 0xea, 0x33, //0x00000656 shrq         $51, %rdx
+	0x48, 0x0f, 0xaf, 0xca, //0x0000065a imulq        %rdx, %rcx
+	0x48, 0x29, 0xce, //0x0000065e subq         %rcx, %rsi
+	0x83, 0xfa, 0x09, //0x00000661 cmpl         $9, %edx
+	0x0f, 0x87, 0x0f, 0x00, 0x00, 0x00, //0x00000664 ja           LBB0_21
+	0x80, 0xc2, 0x30, //0x0000066a addb         $48, %dl
+	0x88, 0x17, //0x0000066d movb         %dl, (%rdi)
+	0xb9, 0x01, 0x00, 0x00, 0x00, //0x0000066f movl         $1, %ecx
+	0xe9, 0x5c, 0x00, 0x00, 0x00, //0x00000674 jmp          LBB0_24
+	//0x00000679 LBB0_21
+	0x83, 0xfa, 0x63, //0x00000679 cmpl         $99, %edx
+	0x0f, 0x87, 0x1f, 0x00, 0x00, 0x00, //0x0000067c ja           LBB0_23
+	0x89, 0xd0, //0x00000682 movl         %edx, %eax
+	0x48, 0x8d, 0x0d, 0x95, 0x02, 0x00, 0x00, //0x00000684 leaq         $661(%rip), %rcx  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x41, //0x0000068b movb         (%rcx,%rax,2), %dl
+	0x8a, 0x44, 0x41, 0x01, //0x0000068e movb         $1(%rcx,%rax,2), %al
+	0x88, 0x17, //0x00000692 movb         %dl, (%rdi)
+	0x88, 0x47, 0x01, //0x00000694 movb         %al, $1(%rdi)
+	0xb9, 0x02, 0x00, 0x00, 0x00, //0x00000697 movl         $2, %ecx
+	0xe9, 0x34, 0x00, 0x00, 0x00, //0x0000069c jmp          LBB0_24
+	//0x000006a1 LBB0_23
+	0x89, 0xd0, //0x000006a1 movl         %edx, %eax
+	0xc1, 0xe8, 0x02, //0x000006a3 shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x000006a6 imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x000006ac shrl         $17, %eax
+	0x8d, 0x48, 0x30, //0x000006af leal         $48(%rax), %ecx
+	0x88, 0x0f, //0x000006b2 movb         %cl, (%rdi)
+	0x6b, 0xc0, 0x64, //0x000006b4 imull        $100, %eax, %eax
+	0x29, 0xc2, //0x000006b7 subl         %eax, %edx
+	0x0f, 0xb7, 0xc2, //0x000006b9 movzwl       %dx, %eax
+	0x48, 0x8d, 0x0d, 0x5d, 0x02, 0x00, 0x00, //0x000006bc leaq         $605(%rip), %rcx  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x41, //0x000006c3 movb         (%rcx,%rax,2), %dl
+	0x8a, 0x44, 0x41, 0x01, //0x000006c6 movb         $1(%rcx,%rax,2), %al
+	0x88, 0x57, 0x01, //0x000006ca movb         %dl, $1(%rdi)
+	0x88, 0x47, 0x02, //0x000006cd movb         %al, $2(%rdi)
+	0xb9, 0x03, 0x00, 0x00, 0x00, //0x000006d0 movl         $3, %ecx
+	//0x000006d5 LBB0_24
+	0x48, 0xba, 0xfd, 0xce, 0x61, 0x84, 0x11, 0x77, 0xcc, 0xab, //0x000006d5 movabsq      $-6067343680855748867, %rdx
+	0x48, 0x89, 0xf0, //0x000006df movq         %rsi, %rax
+	0x48, 0xf7, 0xe2, //0x000006e2 mulq         %rdx
+	0x48, 0xc1, 0xea, 0x1a, //0x000006e5 shrq         $26, %rdx
+	0xc5, 0xf9, 0x6e, 0xc2, //0x000006e9 vmovd        %edx, %xmm0
+	0xc5, 0xfa, 0x6f, 0x0d, 0x0b, 0xf9, 0xff, 0xff, //0x000006ed vmovdqu      $-1781(%rip), %xmm1  /* LCPI0_0+0(%rip) */
+	0xc5, 0xf9, 0xf4, 0xd1, //0x000006f5 vpmuludq     %xmm1, %xmm0, %xmm2
+	0xc5, 0xe9, 0x73, 0xd2, 0x2d, //0x000006f9 vpsrlq       $45, %xmm2, %xmm2
+	0xb8, 0x10, 0x27, 0x00, 0x00, //0x000006fe movl         $10000, %eax
+	0xc4, 0xe1, 0xf9, 0x6e, 0xd8, //0x00000703 vmovq        %rax, %xmm3
+	0xc5, 0xe9, 0xf4, 0xe3, //0x00000708 vpmuludq     %xmm3, %xmm2, %xmm4
+	0xc5, 0xf9, 0xfa, 0xc4, //0x0000070c vpsubd       %xmm4, %xmm0, %xmm0
+	0xc5, 0xe9, 0x61, 0xc0, //0x00000710 vpunpcklwd   %xmm0, %xmm2, %xmm0
+	0xc5, 0xf9, 0x73, 0xf0, 0x02, //0x00000714 vpsllq       $2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x70, 0xc0, 0x50, //0x00000719 vpshuflw     $80, %xmm0, %xmm0
+	0xc5, 0xf9, 0x70, 0xc0, 0x50, //0x0000071e vpshufd      $80, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x15, 0x05, 0xf9, 0xff, 0xff, //0x00000723 vmovddup     $-1787(%rip), %xmm2  /* LCPI0_1+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc2, //0x0000072b vpmulhuw     %xmm2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x25, 0x01, 0xf9, 0xff, 0xff, //0x0000072f vmovddup     $-1791(%rip), %xmm4  /* LCPI0_2+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc4, //0x00000737 vpmulhuw     %xmm4, %xmm0, %xmm0
+	0xc5, 0xfa, 0x6f, 0x2d, 0xcd, 0xf8, 0xff, 0xff, //0x0000073b vmovdqu      $-1843(%rip), %xmm5  /* LCPI0_3+0(%rip) */
+	0xc5, 0xf9, 0xd5, 0xf5, //0x00000743 vpmullw      %xmm5, %xmm0, %xmm6
+	0xc5, 0xc9, 0x73, 0xf6, 0x10, //0x00000747 vpsllq       $16, %xmm6, %xmm6
+	0xc5, 0xf9, 0xf9, 0xc6, //0x0000074c vpsubw       %xmm6, %xmm0, %xmm0
+	0x69, 0xc2, 0x00, 0xe1, 0xf5, 0x05, //0x00000750 imull        $100000000, %edx, %eax
+	0x29, 0xc6, //0x00000756 subl         %eax, %esi
+	0xc5, 0xf9, 0x6e, 0xf6, //0x00000758 vmovd        %esi, %xmm6
+	0xc5, 0xc9, 0xf4, 0xc9, //0x0000075c vpmuludq     %xmm1, %xmm6, %xmm1
+	0xc5, 0xf1, 0x73, 0xd1, 0x2d, //0x00000760 vpsrlq       $45, %xmm1, %xmm1
+	0xc5, 0xf1, 0xf4, 0xdb, //0x00000765 vpmuludq     %xmm3, %xmm1, %xmm3
+	0xc5, 0xc9, 0xfa, 0xdb, //0x00000769 vpsubd       %xmm3, %xmm6, %xmm3
+	0xc5, 0xf1, 0x61, 0xcb, //0x0000076d vpunpcklwd   %xmm3, %xmm1, %xmm1
+	0xc5, 0xf1, 0x73, 0xf1, 0x02, //0x00000771 vpsllq       $2, %xmm1, %xmm1
+	0xc5, 0xfb, 0x70, 0xc9, 0x50, //0x00000776 vpshuflw     $80, %xmm1, %xmm1
+	0xc5, 0xf9, 0x70, 0xc9, 0x50, //0x0000077b vpshufd      $80, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xca, //0x00000780 vpmulhuw     %xmm2, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xcc, //0x00000784 vpmulhuw     %xmm4, %xmm1, %xmm1
+	0xc5, 0xf1, 0xd5, 0xd5, //0x00000788 vpmullw      %xmm5, %xmm1, %xmm2
+	0xc5, 0xe9, 0x73, 0xf2, 0x10, //0x0000078c vpsllq       $16, %xmm2, %xmm2
+	0xc5, 0xf1, 0xf9, 0xca, //0x00000791 vpsubw       %xmm2, %xmm1, %xmm1
+	0xc5, 0xf9, 0x67, 0xc1, //0x00000795 vpackuswb    %xmm1, %xmm0, %xmm0
+	0xc5, 0xf9, 0xfc, 0x05, 0x7f, 0xf8, 0xff, 0xff, //0x00000799 vpaddb       $-1921(%rip), %xmm0, %xmm0  /* LCPI0_4+0(%rip) */
+	0x89, 0xc8, //0x000007a1 movl         %ecx, %eax
+	0xc5, 0xfa, 0x7f, 0x04, 0x07, //0x000007a3 vmovdqu      %xmm0, (%rdi,%rax)
+	0x83, 0xc9, 0x10, //0x000007a8 orl          $16, %ecx
+	0x89, 0xc8, //0x000007ab movl         %ecx, %eax
+	0x5d, //0x000007ad popq         %rbp
+	0xc3, //0x000007ae retq         
+	//0x000007af LBB0_43
+	0x48, 0xba, 0x57, 0x78, 0x13, 0xb1, 0x2f, 0x65, 0xa5, 0x39, //0x000007af movabsq      $4153837486827862103, %rdx
+	0x48, 0x89, 0xf0, //0x000007b9 movq         %rsi, %rax
+	0x48, 0xf7, 0xe2, //0x000007bc mulq         %rdx
+	0x48, 0xc1, 0xea, 0x33, //0x000007bf shrq         $51, %rdx
+	0x48, 0x0f, 0xaf, 0xca, //0x000007c3 imulq        %rdx, %rcx
+	0x48, 0x29, 0xce, //0x000007c7 subq         %rcx, %rsi
+	0x83, 0xfa, 0x09, //0x000007ca cmpl         $9, %edx
+	0x0f, 0x87, 0x10, 0x00, 0x00, 0x00, //0x000007cd ja           LBB0_45
+	0x80, 0xc2, 0x30, //0x000007d3 addb         $48, %dl
+	0x88, 0x57, 0x01, //0x000007d6 movb         %dl, $1(%rdi)
+	0xb9, 0x01, 0x00, 0x00, 0x00, //0x000007d9 movl         $1, %ecx
+	0xe9, 0x5e, 0x00, 0x00, 0x00, //0x000007de jmp          LBB0_48
+	//0x000007e3 LBB0_45
+	0x83, 0xfa, 0x63, //0x000007e3 cmpl         $99, %edx
+	0x0f, 0x87, 0x20, 0x00, 0x00, 0x00, //0x000007e6 ja           LBB0_47
+	0x89, 0xd0, //0x000007ec movl         %edx, %eax
+	0x48, 0x8d, 0x0d, 0x2b, 0x01, 0x00, 0x00, //0x000007ee leaq         $299(%rip), %rcx  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x41, //0x000007f5 movb         (%rcx,%rax,2), %dl
+	0x8a, 0x44, 0x41, 0x01, //0x000007f8 movb         $1(%rcx,%rax,2), %al
+	0x88, 0x57, 0x01, //0x000007fc movb         %dl, $1(%rdi)
+	0x88, 0x47, 0x02, //0x000007ff movb         %al, $2(%rdi)
+	0xb9, 0x02, 0x00, 0x00, 0x00, //0x00000802 movl         $2, %ecx
+	0xe9, 0x35, 0x00, 0x00, 0x00, //0x00000807 jmp          LBB0_48
+	//0x0000080c LBB0_47
+	0x89, 0xd0, //0x0000080c movl         %edx, %eax
+	0xc1, 0xe8, 0x02, //0x0000080e shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x00000811 imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x00000817 shrl         $17, %eax
+	0x8d, 0x48, 0x30, //0x0000081a leal         $48(%rax), %ecx
+	0x88, 0x4f, 0x01, //0x0000081d movb         %cl, $1(%rdi)
+	0x6b, 0xc0, 0x64, //0x00000820 imull        $100, %eax, %eax
+	0x29, 0xc2, //0x00000823 subl         %eax, %edx
+	0x0f, 0xb7, 0xc2, //0x00000825 movzwl       %dx, %eax
+	0x48, 0x8d, 0x0d, 0xf1, 0x00, 0x00, 0x00, //0x00000828 leaq         $241(%rip), %rcx  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x41, //0x0000082f movb         (%rcx,%rax,2), %dl
+	0x8a, 0x44, 0x41, 0x01, //0x00000832 movb         $1(%rcx,%rax,2), %al
+	0x88, 0x57, 0x02, //0x00000836 movb         %dl, $2(%rdi)
+	0x88, 0x47, 0x03, //0x00000839 movb         %al, $3(%rdi)
+	0xb9, 0x03, 0x00, 0x00, 0x00, //0x0000083c movl         $3, %ecx
+	//0x00000841 LBB0_48
+	0x48, 0xba, 0xfd, 0xce, 0x61, 0x84, 0x11, 0x77, 0xcc, 0xab, //0x00000841 movabsq      $-6067343680855748867, %rdx
+	0x48, 0x89, 0xf0, //0x0000084b movq         %rsi, %rax
+	0x48, 0xf7, 0xe2, //0x0000084e mulq         %rdx
+	0x48, 0xc1, 0xea, 0x1a, //0x00000851 shrq         $26, %rdx
+	0xc5, 0xf9, 0x6e, 0xc2, //0x00000855 vmovd        %edx, %xmm0
+	0xc5, 0xfa, 0x6f, 0x0d, 0x9f, 0xf7, 0xff, 0xff, //0x00000859 vmovdqu      $-2145(%rip), %xmm1  /* LCPI0_0+0(%rip) */
+	0xc5, 0xf9, 0xf4, 0xd1, //0x00000861 vpmuludq     %xmm1, %xmm0, %xmm2
+	0xc5, 0xe9, 0x73, 0xd2, 0x2d, //0x00000865 vpsrlq       $45, %xmm2, %xmm2
+	0xb8, 0x10, 0x27, 0x00, 0x00, //0x0000086a movl         $10000, %eax
+	0xc4, 0xe1, 0xf9, 0x6e, 0xd8, //0x0000086f vmovq        %rax, %xmm3
+	0xc5, 0xe9, 0xf4, 0xe3, //0x00000874 vpmuludq     %xmm3, %xmm2, %xmm4
+	0xc5, 0xf9, 0xfa, 0xc4, //0x00000878 vpsubd       %xmm4, %xmm0, %xmm0
+	0xc5, 0xe9, 0x61, 0xc0, //0x0000087c vpunpcklwd   %xmm0, %xmm2, %xmm0
+	0xc5, 0xf9, 0x73, 0xf0, 0x02, //0x00000880 vpsllq       $2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x70, 0xc0, 0x50, //0x00000885 vpshuflw     $80, %xmm0, %xmm0
+	0xc5, 0xf9, 0x70, 0xc0, 0x50, //0x0000088a vpshufd      $80, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x15, 0x99, 0xf7, 0xff, 0xff, //0x0000088f vmovddup     $-2151(%rip), %xmm2  /* LCPI0_1+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc2, //0x00000897 vpmulhuw     %xmm2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x25, 0x95, 0xf7, 0xff, 0xff, //0x0000089b vmovddup     $-2155(%rip), %xmm4  /* LCPI0_2+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc4, //0x000008a3 vpmulhuw     %xmm4, %xmm0, %xmm0
+	0xc5, 0xfa, 0x6f, 0x2d, 0x61, 0xf7, 0xff, 0xff, //0x000008a7 vmovdqu      $-2207(%rip), %xmm5  /* LCPI0_3+0(%rip) */
+	0xc5, 0xf9, 0xd5, 0xf5, //0x000008af vpmullw      %xmm5, %xmm0, %xmm6
+	0xc5, 0xc9, 0x73, 0xf6, 0x10, //0x000008b3 vpsllq       $16, %xmm6, %xmm6
+	0xc5, 0xf9, 0xf9, 0xc6, //0x000008b8 vpsubw       %xmm6, %xmm0, %xmm0
+	0x69, 0xc2, 0x00, 0xe1, 0xf5, 0x05, //0x000008bc imull        $100000000, %edx, %eax
+	0x29, 0xc6, //0x000008c2 subl         %eax, %esi
+	0xc5, 0xf9, 0x6e, 0xf6, //0x000008c4 vmovd        %esi, %xmm6
+	0xc5, 0xc9, 0xf4, 0xc9, //0x000008c8 vpmuludq     %xmm1, %xmm6, %xmm1
+	0xc5, 0xf1, 0x73, 0xd1, 0x2d, //0x000008cc vpsrlq       $45, %xmm1, %xmm1
+	0xc5, 0xf1, 0xf4, 0xdb, //0x000008d1 vpmuludq     %xmm3, %xmm1, %xmm3
+	0xc5, 0xc9, 0xfa, 0xdb, //0x000008d5 vpsubd       %xmm3, %xmm6, %xmm3
+	0xc5, 0xf1, 0x61, 0xcb, //0x000008d9 vpunpcklwd   %xmm3, %xmm1, %xmm1
+	0xc5, 0xf1, 0x73, 0xf1, 0x02, //0x000008dd vpsllq       $2, %xmm1, %xmm1
+	0xc5, 0xfb, 0x70, 0xc9, 0x50, //0x000008e2 vpshuflw     $80, %xmm1, %xmm1
+	0xc5, 0xf9, 0x70, 0xc9, 0x50, //0x000008e7 vpshufd      $80, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xca, //0x000008ec vpmulhuw     %xmm2, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xcc, //0x000008f0 vpmulhuw     %xmm4, %xmm1, %xmm1
+	0xc5, 0xf1, 0xd5, 0xd5, //0x000008f4 vpmullw      %xmm5, %xmm1, %xmm2
+	0xc5, 0xe9, 0x73, 0xf2, 0x10, //0x000008f8 vpsllq       $16, %xmm2, %xmm2
+	0xc5, 0xf1, 0xf9, 0xca, //0x000008fd vpsubw       %xmm2, %xmm1, %xmm1
+	0xc5, 0xf9, 0x67, 0xc1, //0x00000901 vpackuswb    %xmm1, %xmm0, %xmm0
+	0xc5, 0xf9, 0xfc, 0x05, 0x13, 0xf7, 0xff, 0xff, //0x00000905 vpaddb       $-2285(%rip), %xmm0, %xmm0  /* LCPI0_4+0(%rip) */
+	0x89, 0xc8, //0x0000090d movl         %ecx, %eax
+	0xc5, 0xfa, 0x7f, 0x44, 0x07, 0x01, //0x0000090f vmovdqu      %xmm0, $1(%rdi,%rax)
+	0x83, 0xc9, 0x10, //0x00000915 orl          $16, %ecx
+	0xff, 0xc1, //0x00000918 incl         %ecx
+	0x89, 0xc8, //0x0000091a movl         %ecx, %eax
+	0x5d, //0x0000091c popq         %rbp
+	0xc3, //0x0000091d retq         
+	0x00, 0x00, //0x0000091e .p2align 4, 0x00
+	//0x00000920 _Digits
+	0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x35, 0x30, 0x36, 0x30, 0x37, //0x00000920 QUAD $0x3330323031303030; QUAD $0x3730363035303430  // .ascii 16, '0001020304050607'
+	0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x31, 0x31, 0x31, 0x32, 0x31, 0x33, 0x31, 0x34, 0x31, 0x35, //0x00000930 QUAD $0x3131303139303830; QUAD $0x3531343133313231  // .ascii 16, '0809101112131415'
+	0x31, 0x36, 0x31, 0x37, 0x31, 0x38, 0x31, 0x39, 0x32, 0x30, 0x32, 0x31, 0x32, 0x32, 0x32, 0x33, //0x00000940 QUAD $0x3931383137313631; QUAD $0x3332323231323032  // .ascii 16, '1617181920212223'
+	0x32, 0x34, 0x32, 0x35, 0x32, 0x36, 0x32, 0x37, 0x32, 0x38, 0x32, 0x39, 0x33, 0x30, 0x33, 0x31, //0x00000950 QUAD $0x3732363235323432; QUAD $0x3133303339323832  // .ascii 16, '2425262728293031'
+	0x33, 0x32, 0x33, 0x33, 0x33, 0x34, 0x33, 0x35, 0x33, 0x36, 0x33, 0x37, 0x33, 0x38, 0x33, 0x39, //0x00000960 QUAD $0x3533343333333233; QUAD $0x3933383337333633  // .ascii 16, '3233343536373839'
+	0x34, 0x30, 0x34, 0x31, 0x34, 0x32, 0x34, 0x33, 0x34, 0x34, 0x34, 0x35, 0x34, 0x36, 0x34, 0x37, //0x00000970 QUAD $0x3334323431343034; QUAD $0x3734363435343434  // .ascii 16, '4041424344454647'
+	0x34, 0x38, 0x34, 0x39, 0x35, 0x30, 0x35, 0x31, 0x35, 0x32, 0x35, 0x33, 0x35, 0x34, 0x35, 0x35, //0x00000980 QUAD $0x3135303539343834; QUAD $0x3535343533353235  // .ascii 16, '4849505152535455'
+	0x35, 0x36, 0x35, 0x37, 0x35, 0x38, 0x35, 0x39, 0x36, 0x30, 0x36, 0x31, 0x36, 0x32, 0x36, 0x33, //0x00000990 QUAD $0x3935383537353635; QUAD $0x3336323631363036  // .ascii 16, '5657585960616263'
+	0x36, 0x34, 0x36, 0x35, 0x36, 0x36, 0x36, 0x37, 0x36, 0x38, 0x36, 0x39, 0x37, 0x30, 0x37, 0x31, //0x000009a0 QUAD $0x3736363635363436; QUAD $0x3137303739363836  // .ascii 16, '6465666768697071'
+	0x37, 0x32, 0x37, 0x33, 0x37, 0x34, 0x37, 0x35, 0x37, 0x36, 0x37, 0x37, 0x37, 0x38, 0x37, 0x39, //0x000009b0 QUAD $0x3537343733373237; QUAD $0x3937383737373637  // .ascii 16, '7273747576777879'
+	0x38, 0x30, 0x38, 0x31, 0x38, 0x32, 0x38, 0x33, 0x38, 0x34, 0x38, 0x35, 0x38, 0x36, 0x38, 0x37, //0x000009c0 QUAD $0x3338323831383038; QUAD $0x3738363835383438  // .ascii 16, '8081828384858687'
+	0x38, 0x38, 0x38, 0x39, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x34, 0x39, 0x35, //0x000009d0 QUAD $0x3139303939383838; QUAD $0x3539343933393239  // .ascii 16, '8889909192939495'
+	0x39, 0x36, 0x39, 0x37, 0x39, 0x38, 0x39, 0x39, //0x000009e0 QUAD $0x3939383937393639  // .ascii 8, '96979899'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009e8 .p2align 4, 0x00
+	//0x000009f0 _VecShiftShuffles
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, //0x000009f0 QUAD $0x0706050403020100; QUAD $0x0f0e0d0c0b0a0908  // .ascii 16, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'
+	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, //0x00000a00 QUAD $0x0807060504030201; QUAD $0xff0f0e0d0c0b0a09  // .ascii 16, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff'
+	0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, //0x00000a10 QUAD $0x0908070605040302; QUAD $0xffff0f0e0d0c0b0a  // .ascii 16, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff'
+	0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, //0x00000a20 QUAD $0x0a09080706050403; QUAD $0xffffff0f0e0d0c0b  // .ascii 16, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff'
+	0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, //0x00000a30 QUAD $0x0b0a090807060504; QUAD $0xffffffff0f0e0d0c  // .ascii 16, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff'
+	0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000a40 QUAD $0x0c0b0a0908070605; QUAD $0xffffffffff0f0e0d  // .ascii 16, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff'
+	0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000a50 QUAD $0x0d0c0b0a09080706; QUAD $0xffffffffffff0f0e  // .ascii 16, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff'
+	0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000a60 QUAD $0x0e0d0c0b0a090807; QUAD $0xffffffffffffff0f  // .ascii 16, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff'
+	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000a70 QUAD $0x0f0e0d0c0b0a0908; QUAD $0xffffffffffffffff  // .ascii 16, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff'
+}
+ 

vendor/github.com/bytedance/sonic/internal/native/avx/lspace.go

@@ -0,0 +1,36 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_lspace func(sp unsafe.Pointer, nb int, off int) (ret int)
+
+var S_lspace uintptr
+
+//go:nosplit
+func lspace(sp *byte, nb int, off int) (ret int) {
+    return F_lspace(rt.NoEscape(unsafe.Pointer(sp)), nb, off)
+}

vendor/github.com/bytedance/sonic/internal/native/avx/lspace_subr.go

@@ -0,0 +1,37 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__lspace = 0
+)
+
+const (
+    _stack__lspace = 8
+)
+
+const (
+    _size__lspace = 113
+)
+
+var (
+    _pcsp__lspace = [][2]uint32{
+        {1, 0},
+        {89, 8},
+        {90, 0},
+        {103, 8},
+        {104, 0},
+        {111, 8},
+        {112, 0},
+    }
+)
+
+var _cfunc_lspace = []loader.CFunc{
+    {"_lspace_entry", 0,  _entry__lspace, 0, nil},
+    {"_lspace", _entry__lspace, _size__lspace, _stack__lspace, _pcsp__lspace},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/lspace_text_amd64.go

@@ -0,0 +1,44 @@
+// +build amd64
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+var _text_lspace = []byte{
+	// .p2align 4, 0x90
+	// _lspace
+	0x55, // pushq        %rbp
+	0x48, 0x89, 0xe5, //0x00000001 movq         %rsp, %rbp
+	0x48, 0x39, 0xd6, //0x00000004 cmpq         %rdx, %rsi
+	0x0f, 0x84, 0x4e, 0x00, 0x00, 0x00, //0x00000007 je           LBB0_1
+	0x4c, 0x8d, 0x04, 0x37, //0x0000000d leaq         (%rdi,%rsi), %r8
+	0x48, 0x8d, 0x44, 0x3a, 0x01, //0x00000011 leaq         $1(%rdx,%rdi), %rax
+	0x48, 0x29, 0xf2, //0x00000016 subq         %rsi, %rdx
+	0x48, 0xbe, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x00000019 movabsq      $4294977024, %rsi
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000023 .p2align 4, 0x90
+	//0x00000030 LBB0_3
+	0x0f, 0xbe, 0x48, 0xff, //0x00000030 movsbl       $-1(%rax), %ecx
+	0x83, 0xf9, 0x20, //0x00000034 cmpl         $32, %ecx
+	0x0f, 0x87, 0x2c, 0x00, 0x00, 0x00, //0x00000037 ja           LBB0_5
+	0x48, 0x0f, 0xa3, 0xce, //0x0000003d btq          %rcx, %rsi
+	0x0f, 0x83, 0x22, 0x00, 0x00, 0x00, //0x00000041 jae          LBB0_5
+	0x48, 0xff, 0xc0, //0x00000047 incq         %rax
+	0x48, 0xff, 0xc2, //0x0000004a incq         %rdx
+	0x0f, 0x85, 0xdd, 0xff, 0xff, 0xff, //0x0000004d jne          LBB0_3
+	0x49, 0x29, 0xf8, //0x00000053 subq         %rdi, %r8
+	0x4c, 0x89, 0xc0, //0x00000056 movq         %r8, %rax
+	0x5d, //0x00000059 popq         %rbp
+	0xc3, //0x0000005a retq         
+	//0x0000005b LBB0_1
+	0x48, 0x01, 0xfa, //0x0000005b addq         %rdi, %rdx
+	0x49, 0x89, 0xd0, //0x0000005e movq         %rdx, %r8
+	0x49, 0x29, 0xf8, //0x00000061 subq         %rdi, %r8
+	0x4c, 0x89, 0xc0, //0x00000064 movq         %r8, %rax
+	0x5d, //0x00000067 popq         %rbp
+	0xc3, //0x00000068 retq         
+	//0x00000069 LBB0_5
+	0x48, 0xf7, 0xd7, //0x00000069 notq         %rdi
+	0x48, 0x01, 0xf8, //0x0000006c addq         %rdi, %rax
+	0x5d, //0x0000006f popq         %rbp
+	0xc3, //0x00000070 retq         
+}
+ 

vendor/github.com/bytedance/sonic/internal/native/avx/native_export.go

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `github.com/bytedance/sonic/loader`
+)
+
+
+func Use() {
+    loader.WrapGoC(_text_f64toa, _cfunc_f64toa, []loader.GoC{{"_f64toa", &S_f64toa, &F_f64toa}}, "avx", "avx/f64toa.c")
+    loader.WrapGoC(_text_f32toa, _cfunc_f32toa, []loader.GoC{{"_f32toa", &S_f32toa, &F_f32toa}}, "avx", "avx/f32toa.c")
+    loader.WrapGoC(_text_get_by_path, _cfunc_get_by_path, []loader.GoC{{"_get_by_path", &S_get_by_path, &F_get_by_path}}, "avx", "avx/get_by_path.c")
+    loader.WrapGoC(_text_html_escape, _cfunc_html_escape, []loader.GoC{{"_html_escape", &S_html_escape, &F_html_escape}}, "avx", "avx/html_escape.c")
+    loader.WrapGoC(_text_i64toa, _cfunc_i64toa, []loader.GoC{{"_i64toa", &S_i64toa, &F_i64toa}}, "avx", "avx/i64toa.c")
+    loader.WrapGoC(_text_lspace, _cfunc_lspace, []loader.GoC{{"_lspace", &S_lspace, &F_lspace}}, "avx", "avx/lspace.c")
+    loader.WrapGoC(_text_quote, _cfunc_quote, []loader.GoC{{"_quote", &S_quote, &F_quote}}, "avx", "avx/quote.c")
+    loader.WrapGoC(_text_skip_array, _cfunc_skip_array, []loader.GoC{{"_skip_array", &S_skip_array, &F_skip_array}}, "avx", "avx/skip_array.c")
+    loader.WrapGoC(_text_skip_number, _cfunc_skip_number, []loader.GoC{{"_skip_number", &S_skip_number, &F_skip_number}}, "avx", "avx/skip_number.c")
+    loader.WrapGoC(_text_skip_one, _cfunc_skip_one, []loader.GoC{{"_skip_one", &S_skip_one, &F_skip_one}}, "avx", "avx/skip_one.c")
+    loader.WrapGoC(_text_skip_object, _cfunc_skip_object, []loader.GoC{{"_skip_object", &S_skip_object, &F_skip_object}}, "avx", "avx/skip_object.c")
+    loader.WrapGoC(_text_skip_one_fast, _cfunc_skip_one_fast, []loader.GoC{{"_skip_one_fast", &S_skip_one_fast, &F_skip_one_fast}}, "avx", "avx/skip_one_fast.c")
+    loader.WrapGoC(_text_u64toa, _cfunc_u64toa, []loader.GoC{{"_u64toa", &S_u64toa, &F_u64toa}}, "avx", "avx/u64toa.c")
+    loader.WrapGoC(_text_unquote, _cfunc_unquote, []loader.GoC{{"_unquote", &S_unquote, &F_unquote}}, "avx", "avx/unquote.c")
+    loader.WrapGoC(_text_validate_one, _cfunc_validate_one, []loader.GoC{{"_validate_one", &S_validate_one, &F_validate_one}}, "avx", "avx/validate_one.c")
+    loader.WrapGoC(_text_validate_utf8, _cfunc_validate_utf8, []loader.GoC{{"_validate_utf8", &S_validate_utf8, &F_validate_utf8}}, "avx", "avx/validate_utf8.c")
+    loader.WrapGoC(_text_validate_utf8_fast, _cfunc_validate_utf8_fast, []loader.GoC{{"_validate_utf8_fast", &S_validate_utf8_fast, &F_validate_utf8_fast}}, "avx", "avx/validate_utf8_fast.c")
+    loader.WrapGoC(_text_vnumber, _cfunc_vnumber, []loader.GoC{{"_vnumber", &S_vnumber, &F_vnumber}}, "avx", "avx/vnumber.c")
+    loader.WrapGoC(_text_vsigned, _cfunc_vsigned, []loader.GoC{{"_vsigned", &S_vsigned, &F_vsigned}}, "avx", "avx/vsigned.c")
+    loader.WrapGoC(_text_vunsigned, _cfunc_vunsigned, []loader.GoC{{"_vunsigned", &S_vunsigned, &F_vunsigned}}, "avx", "avx/vunsigned.c")
+    loader.WrapGoC(_text_vstring, _cfunc_vstring, []loader.GoC{{"_vstring", &S_vstring, &F_vstring}}, "avx", "avx/vstring.c")
+    loader.WrapGoC(_text_value, _cfunc_value, []loader.GoC{{"_value", &S_value, &F_value}}, "avx", "avx/value.c")
+}

vendor/github.com/bytedance/sonic/internal/native/avx/quote.go

@@ -0,0 +1,35 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+var F_quote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer, flags uint64) (ret int)
+
+var S_quote uintptr
+
+//go:nosplit
+func quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int) {
+    return F_quote(rt.NoEscape(sp), nb, rt.NoEscape(dp), rt.NoEscape(unsafe.Pointer(dn)), flags)
+}

vendor/github.com/bytedance/sonic/internal/native/avx/quote_subr.go

@@ -0,0 +1,46 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__quote = 48
+)
+
+const (
+    _stack__quote = 56
+)
+
+const (
+    _size__quote = 1696
+)
+
+var (
+    _pcsp__quote = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1649, 56},
+        {1653, 48},
+        {1654, 40},
+        {1656, 32},
+        {1658, 24},
+        {1660, 16},
+        {1662, 8},
+        {1663, 0},
+        {1690, 56},
+    }
+)
+
+var _cfunc_quote = []loader.CFunc{
+    {"_quote_entry", 0,  _entry__quote, 0, nil},
+    {"_quote", _entry__quote, _size__quote, _stack__quote, _pcsp__quote},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/skip_array.go

@@ -0,0 +1,37 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the     License    );
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an     AS IS     BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_skip_array func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+var S_skip_array uintptr
+
+//go:nosplit
+func skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return F_skip_array(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}

vendor/github.com/bytedance/sonic/internal/native/avx/skip_array_subr.go

@@ -0,0 +1,46 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__skip_array = 160
+)
+
+const (
+    _stack__skip_array = 152
+)
+
+const (
+    _size__skip_array = 9524
+)
+
+var (
+    _pcsp__skip_array = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {8962, 152},
+        {8966, 48},
+        {8967, 40},
+        {8969, 32},
+        {8971, 24},
+        {8973, 16},
+        {8975, 8},
+        {8976, 0},
+        {9524, 152},
+    }
+)
+
+var _cfunc_skip_array = []loader.CFunc{
+    {"_skip_array_entry", 0,  _entry__skip_array, 0, nil},
+    {"_skip_array", _entry__skip_array, _size__skip_array, _stack__skip_array, _pcsp__skip_array},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/skip_number.go

@@ -0,0 +1,36 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the     License    );
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an     AS IS     BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_skip_number func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
+
+var S_skip_number uintptr
+
+//go:nosplit
+func skip_number(s *string, p *int) (ret int) {
+    return F_skip_number(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}

vendor/github.com/bytedance/sonic/internal/native/avx/skip_number_subr.go

@@ -0,0 +1,46 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__skip_number = 112
+)
+
+const (
+    _stack__skip_number = 72
+)
+
+const (
+    _size__skip_number = 1108
+)
+
+var (
+    _pcsp__skip_number = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1025, 72},
+        {1029, 48},
+        {1030, 40},
+        {1032, 32},
+        {1034, 24},
+        {1036, 16},
+        {1038, 8},
+        {1039, 0},
+        {1108, 72},
+    }
+)
+
+var _cfunc_skip_number = []loader.CFunc{
+    {"_skip_number_entry", 0,  _entry__skip_number, 0, nil},
+    {"_skip_number", _entry__skip_number, _size__skip_number, _stack__skip_number, _pcsp__skip_number},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/skip_number_text_amd64.go

@@ -0,0 +1,394 @@
+// +build amd64
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+var _text_skip_number = []byte{
+	// .p2align 4, 0x00
+	// LCPI0_0
+	0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, // QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f  // .space 16, '////////////////'
+	//0x00000010 LCPI0_1
+	0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, //0x00000010 QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a  // .space 16, '::::::::::::::::'
+	//0x00000020 LCPI0_2
+	0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, //0x00000020 QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b  // .space 16, '++++++++++++++++'
+	//0x00000030 LCPI0_3
+	0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, //0x00000030 QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d  // .space 16, '----------------'
+	//0x00000040 LCPI0_4
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //0x00000040 QUAD $0x2020202020202020; QUAD $0x2020202020202020  // .space 16, '                '
+	//0x00000050 LCPI0_5
+	0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, //0x00000050 QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e  // .space 16, '................'
+	//0x00000060 LCPI0_6
+	0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, //0x00000060 QUAD $0x6565656565656565; QUAD $0x6565656565656565  // .space 16, 'eeeeeeeeeeeeeeee'
+	//0x00000070 .p2align 4, 0x90
+	//0x00000070 _skip_number
+	0x55, //0x00000070 pushq        %rbp
+	0x48, 0x89, 0xe5, //0x00000071 movq         %rsp, %rbp
+	0x41, 0x57, //0x00000074 pushq        %r15
+	0x41, 0x56, //0x00000076 pushq        %r14
+	0x41, 0x55, //0x00000078 pushq        %r13
+	0x41, 0x54, //0x0000007a pushq        %r12
+	0x53, //0x0000007c pushq        %rbx
+	0x48, 0x83, 0xec, 0x18, //0x0000007d subq         $24, %rsp
+	0x48, 0x8b, 0x1f, //0x00000081 movq         (%rdi), %rbx
+	0x4c, 0x8b, 0x6f, 0x08, //0x00000084 movq         $8(%rdi), %r13
+	0x48, 0x8b, 0x16, //0x00000088 movq         (%rsi), %rdx
+	0x49, 0x29, 0xd5, //0x0000008b subq         %rdx, %r13
+	0x31, 0xc0, //0x0000008e xorl         %eax, %eax
+	0x80, 0x3c, 0x13, 0x2d, //0x00000090 cmpb         $45, (%rbx,%rdx)
+	0x4c, 0x8d, 0x3c, 0x13, //0x00000094 leaq         (%rbx,%rdx), %r15
+	0x0f, 0x94, 0xc0, //0x00000098 sete         %al
+	0x49, 0x01, 0xc7, //0x0000009b addq         %rax, %r15
+	0x49, 0x29, 0xc5, //0x0000009e subq         %rax, %r13
+	0x0f, 0x84, 0xee, 0x03, 0x00, 0x00, //0x000000a1 je           LBB0_1
+	0x41, 0x8a, 0x3f, //0x000000a7 movb         (%r15), %dil
+	0x8d, 0x4f, 0xd0, //0x000000aa leal         $-48(%rdi), %ecx
+	0x48, 0xc7, 0xc0, 0xfe, 0xff, 0xff, 0xff, //0x000000ad movq         $-2, %rax
+	0x80, 0xf9, 0x09, //0x000000b4 cmpb         $9, %cl
+	0x0f, 0x87, 0xae, 0x03, 0x00, 0x00, //0x000000b7 ja           LBB0_59
+	0x40, 0x80, 0xff, 0x30, //0x000000bd cmpb         $48, %dil
+	0x0f, 0x85, 0x34, 0x00, 0x00, 0x00, //0x000000c1 jne          LBB0_7
+	0xbf, 0x01, 0x00, 0x00, 0x00, //0x000000c7 movl         $1, %edi
+	0x49, 0x83, 0xfd, 0x01, //0x000000cc cmpq         $1, %r13
+	0x0f, 0x84, 0x6a, 0x03, 0x00, 0x00, //0x000000d0 je           LBB0_58
+	0x41, 0x8a, 0x47, 0x01, //0x000000d6 movb         $1(%r15), %al
+	0x04, 0xd2, //0x000000da addb         $-46, %al
+	0x3c, 0x37, //0x000000dc cmpb         $55, %al
+	0x0f, 0x87, 0x5c, 0x03, 0x00, 0x00, //0x000000de ja           LBB0_58
+	0x0f, 0xb6, 0xc0, //0x000000e4 movzbl       %al, %eax
+	0x48, 0xb9, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, //0x000000e7 movabsq      $36028797027352577, %rcx
+	0x48, 0x0f, 0xa3, 0xc1, //0x000000f1 btq          %rax, %rcx
+	0x0f, 0x83, 0x45, 0x03, 0x00, 0x00, //0x000000f5 jae          LBB0_58
+	//0x000000fb LBB0_7
+	0x48, 0x89, 0x55, 0xd0, //0x000000fb movq         %rdx, $-48(%rbp)
+	0x49, 0x83, 0xfd, 0x10, //0x000000ff cmpq         $16, %r13
+	0x0f, 0x82, 0x98, 0x03, 0x00, 0x00, //0x00000103 jb           LBB0_8
+	0x48, 0x89, 0x5d, 0xc8, //0x00000109 movq         %rbx, $-56(%rbp)
+	0x48, 0x89, 0x75, 0xc0, //0x0000010d movq         %rsi, $-64(%rbp)
+	0x4d, 0x8d, 0x45, 0xf0, //0x00000111 leaq         $-16(%r13), %r8
+	0x4c, 0x89, 0xc0, //0x00000115 movq         %r8, %rax
+	0x48, 0x83, 0xe0, 0xf0, //0x00000118 andq         $-16, %rax
+	0x4e, 0x8d, 0x64, 0x38, 0x10, //0x0000011c leaq         $16(%rax,%r15), %r12
+	0x41, 0x83, 0xe0, 0x0f, //0x00000121 andl         $15, %r8d
+	0x49, 0xc7, 0xc3, 0xff, 0xff, 0xff, 0xff, //0x00000125 movq         $-1, %r11
+	0xc5, 0x7a, 0x6f, 0x05, 0xcc, 0xfe, 0xff, 0xff, //0x0000012c vmovdqu      $-308(%rip), %xmm8  /* LCPI0_0+0(%rip) */
+	0xc5, 0x7a, 0x6f, 0x0d, 0xd4, 0xfe, 0xff, 0xff, //0x00000134 vmovdqu      $-300(%rip), %xmm9  /* LCPI0_1+0(%rip) */
+	0xc5, 0x7a, 0x6f, 0x15, 0xdc, 0xfe, 0xff, 0xff, //0x0000013c vmovdqu      $-292(%rip), %xmm10  /* LCPI0_2+0(%rip) */
+	0xc5, 0x7a, 0x6f, 0x1d, 0xe4, 0xfe, 0xff, 0xff, //0x00000144 vmovdqu      $-284(%rip), %xmm11  /* LCPI0_3+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x25, 0xec, 0xfe, 0xff, 0xff, //0x0000014c vmovdqu      $-276(%rip), %xmm4  /* LCPI0_4+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x2d, 0xf4, 0xfe, 0xff, 0xff, //0x00000154 vmovdqu      $-268(%rip), %xmm5  /* LCPI0_5+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x35, 0xfc, 0xfe, 0xff, 0xff, //0x0000015c vmovdqu      $-260(%rip), %xmm6  /* LCPI0_6+0(%rip) */
+	0x49, 0xc7, 0xc6, 0xff, 0xff, 0xff, 0xff, //0x00000164 movq         $-1, %r14
+	0x49, 0xc7, 0xc2, 0xff, 0xff, 0xff, 0xff, //0x0000016b movq         $-1, %r10
+	0x4c, 0x89, 0xfb, //0x00000172 movq         %r15, %rbx
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000175 .p2align 4, 0x90
+	//0x00000180 LBB0_10
+	0xc5, 0xfa, 0x6f, 0x3b, //0x00000180 vmovdqu      (%rbx), %xmm7
+	0xc4, 0xc1, 0x41, 0x64, 0xc0, //0x00000184 vpcmpgtb     %xmm8, %xmm7, %xmm0
+	0xc5, 0xb1, 0x64, 0xcf, //0x00000189 vpcmpgtb     %xmm7, %xmm9, %xmm1
+	0xc5, 0xf9, 0xdb, 0xc1, //0x0000018d vpand        %xmm1, %xmm0, %xmm0
+	0xc5, 0xa9, 0x74, 0xcf, //0x00000191 vpcmpeqb     %xmm7, %xmm10, %xmm1
+	0xc5, 0xa1, 0x74, 0xd7, //0x00000195 vpcmpeqb     %xmm7, %xmm11, %xmm2
+	0xc5, 0xe9, 0xeb, 0xc9, //0x00000199 vpor         %xmm1, %xmm2, %xmm1
+	0xc5, 0xc1, 0xeb, 0xd4, //0x0000019d vpor         %xmm4, %xmm7, %xmm2
+	0xc5, 0xe9, 0x74, 0xd6, //0x000001a1 vpcmpeqb     %xmm6, %xmm2, %xmm2
+	0xc5, 0xc1, 0x74, 0xfd, //0x000001a5 vpcmpeqb     %xmm5, %xmm7, %xmm7
+	0xc5, 0xe9, 0xeb, 0xdf, //0x000001a9 vpor         %xmm7, %xmm2, %xmm3
+	0xc5, 0xf1, 0xeb, 0xc0, //0x000001ad vpor         %xmm0, %xmm1, %xmm0
+	0xc5, 0xe1, 0xeb, 0xc0, //0x000001b1 vpor         %xmm0, %xmm3, %xmm0
+	0xc5, 0xf9, 0xd7, 0xff, //0x000001b5 vpmovmskb    %xmm7, %edi
+	0xc5, 0xf9, 0xd7, 0xf2, //0x000001b9 vpmovmskb    %xmm2, %esi
+	0xc5, 0xf9, 0xd7, 0xc1, //0x000001bd vpmovmskb    %xmm1, %eax
+	0xc5, 0xf9, 0xd7, 0xc8, //0x000001c1 vpmovmskb    %xmm0, %ecx
+	0xba, 0xff, 0xff, 0xff, 0xff, //0x000001c5 movl         $4294967295, %edx
+	0x48, 0x31, 0xd1, //0x000001ca xorq         %rdx, %rcx
+	0x48, 0x0f, 0xbc, 0xc9, //0x000001cd bsfq         %rcx, %rcx
+	0x83, 0xf9, 0x10, //0x000001d1 cmpl         $16, %ecx
+	0x0f, 0x84, 0x11, 0x00, 0x00, 0x00, //0x000001d4 je           LBB0_12
+	0xba, 0xff, 0xff, 0xff, 0xff, //0x000001da movl         $-1, %edx
+	0xd3, 0xe2, //0x000001df shll         %cl, %edx
+	0xf7, 0xd2, //0x000001e1 notl         %edx
+	0x21, 0xd7, //0x000001e3 andl         %edx, %edi
+	0x21, 0xd6, //0x000001e5 andl         %edx, %esi
+	0x21, 0xc2, //0x000001e7 andl         %eax, %edx
+	0x89, 0xd0, //0x000001e9 movl         %edx, %eax
+	//0x000001eb LBB0_12
+	0x44, 0x8d, 0x4f, 0xff, //0x000001eb leal         $-1(%rdi), %r9d
+	0x41, 0x21, 0xf9, //0x000001ef andl         %edi, %r9d
+	0x0f, 0x85, 0x26, 0x02, 0x00, 0x00, //0x000001f2 jne          LBB0_13
+	0x8d, 0x56, 0xff, //0x000001f8 leal         $-1(%rsi), %edx
+	0x21, 0xf2, //0x000001fb andl         %esi, %edx
+	0x0f, 0x85, 0x10, 0x02, 0x00, 0x00, //0x000001fd jne          LBB0_17
+	0x8d, 0x50, 0xff, //0x00000203 leal         $-1(%rax), %edx
+	0x21, 0xc2, //0x00000206 andl         %eax, %edx
+	0x0f, 0x85, 0x05, 0x02, 0x00, 0x00, //0x00000208 jne          LBB0_17
+	0x85, 0xff, //0x0000020e testl        %edi, %edi
+	0x0f, 0x84, 0x19, 0x00, 0x00, 0x00, //0x00000210 je           LBB0_22
+	0x48, 0x89, 0xda, //0x00000216 movq         %rbx, %rdx
+	0x4c, 0x29, 0xfa, //0x00000219 subq         %r15, %rdx
+	0x0f, 0xbc, 0xff, //0x0000021c bsfl         %edi, %edi
+	0x48, 0x01, 0xd7, //0x0000021f addq         %rdx, %rdi
+	0x49, 0x83, 0xfa, 0xff, //0x00000222 cmpq         $-1, %r10
+	0x0f, 0x85, 0xfc, 0x01, 0x00, 0x00, //0x00000226 jne          LBB0_15
+	0x49, 0x89, 0xfa, //0x0000022c movq         %rdi, %r10
+	//0x0000022f LBB0_22
+	0x85, 0xf6, //0x0000022f testl        %esi, %esi
+	0x0f, 0x84, 0x19, 0x00, 0x00, 0x00, //0x00000231 je           LBB0_25
+	0x48, 0x89, 0xda, //0x00000237 movq         %rbx, %rdx
+	0x4c, 0x29, 0xfa, //0x0000023a subq         %r15, %rdx
+	0x0f, 0xbc, 0xfe, //0x0000023d bsfl         %esi, %edi
+	0x48, 0x01, 0xd7, //0x00000240 addq         %rdx, %rdi
+	0x49, 0x83, 0xfe, 0xff, //0x00000243 cmpq         $-1, %r14
+	0x0f, 0x85, 0xdb, 0x01, 0x00, 0x00, //0x00000247 jne          LBB0_15
+	0x49, 0x89, 0xfe, //0x0000024d movq         %rdi, %r14
+	//0x00000250 LBB0_25
+	0x85, 0xc0, //0x00000250 testl        %eax, %eax
+	0x0f, 0x84, 0x19, 0x00, 0x00, 0x00, //0x00000252 je           LBB0_28
+	0x48, 0x89, 0xda, //0x00000258 movq         %rbx, %rdx
+	0x4c, 0x29, 0xfa, //0x0000025b subq         %r15, %rdx
+	0x0f, 0xbc, 0xf8, //0x0000025e bsfl         %eax, %edi
+	0x48, 0x01, 0xd7, //0x00000261 addq         %rdx, %rdi
+	0x49, 0x83, 0xfb, 0xff, //0x00000264 cmpq         $-1, %r11
+	0x0f, 0x85, 0xba, 0x01, 0x00, 0x00, //0x00000268 jne          LBB0_15
+	0x49, 0x89, 0xfb, //0x0000026e movq         %rdi, %r11
+	//0x00000271 LBB0_28
+	0x83, 0xf9, 0x10, //0x00000271 cmpl         $16, %ecx
+	0x0f, 0x85, 0xb2, 0x00, 0x00, 0x00, //0x00000274 jne          LBB0_60
+	0x48, 0x83, 0xc3, 0x10, //0x0000027a addq         $16, %rbx
+	0x49, 0x83, 0xc5, 0xf0, //0x0000027e addq         $-16, %r13
+	0x49, 0x83, 0xfd, 0x0f, //0x00000282 cmpq         $15, %r13
+	0x0f, 0x87, 0xf4, 0xfe, 0xff, 0xff, //0x00000286 ja           LBB0_10
+	0x4d, 0x85, 0xc0, //0x0000028c testq        %r8, %r8
+	0x48, 0x8b, 0x75, 0xc0, //0x0000028f movq         $-64(%rbp), %rsi
+	0x48, 0x8b, 0x5d, 0xc8, //0x00000293 movq         $-56(%rbp), %rbx
+	0x0f, 0x84, 0x9d, 0x00, 0x00, 0x00, //0x00000297 je           LBB0_42
+	//0x0000029d LBB0_31
+	0x4b, 0x8d, 0x04, 0x04, //0x0000029d leaq         (%r12,%r8), %rax
+	0x48, 0x8d, 0x0d, 0x1c, 0x02, 0x00, 0x00, //0x000002a1 leaq         $540(%rip), %rcx  /* LJTI0_0+0(%rip) */
+	0xe9, 0x0f, 0x00, 0x00, 0x00, //0x000002a8 jmp          LBB0_32
+	0x90, 0x90, 0x90, //0x000002ad .p2align 4, 0x90
+	//0x000002b0 LBB0_40
+	0x49, 0x89, 0xd4, //0x000002b0 movq         %rdx, %r12
+	0x49, 0xff, 0xc8, //0x000002b3 decq         %r8
+	0x0f, 0x84, 0x8f, 0x01, 0x00, 0x00, //0x000002b6 je           LBB0_41
+	//0x000002bc LBB0_32
+	0x41, 0x0f, 0xbe, 0x3c, 0x24, //0x000002bc movsbl       (%r12), %edi
+	0x83, 0xc7, 0xd5, //0x000002c1 addl         $-43, %edi
+	0x83, 0xff, 0x3a, //0x000002c4 cmpl         $58, %edi
+	0x0f, 0x87, 0x6d, 0x00, 0x00, 0x00, //0x000002c7 ja           LBB0_42
+	0x49, 0x8d, 0x54, 0x24, 0x01, //0x000002cd leaq         $1(%r12), %rdx
+	0x48, 0x63, 0x3c, 0xb9, //0x000002d2 movslq       (%rcx,%rdi,4), %rdi
+	0x48, 0x01, 0xcf, //0x000002d6 addq         %rcx, %rdi
+	0xff, 0xe7, //0x000002d9 jmpq         *%rdi
+	//0x000002db LBB0_38
+	0x48, 0x89, 0xd7, //0x000002db movq         %rdx, %rdi
+	0x4c, 0x29, 0xff, //0x000002de subq         %r15, %rdi
+	0x49, 0x83, 0xfb, 0xff, //0x000002e1 cmpq         $-1, %r11
+	0x0f, 0x85, 0x95, 0x01, 0x00, 0x00, //0x000002e5 jne          LBB0_61
+	0x48, 0xff, 0xcf, //0x000002eb decq         %rdi
+	0x49, 0x89, 0xfb, //0x000002ee movq         %rdi, %r11
+	0xe9, 0xba, 0xff, 0xff, 0xff, //0x000002f1 jmp          LBB0_40
+	//0x000002f6 LBB0_36
+	0x48, 0x89, 0xd7, //0x000002f6 movq         %rdx, %rdi
+	0x4c, 0x29, 0xff, //0x000002f9 subq         %r15, %rdi
+	0x49, 0x83, 0xfe, 0xff, //0x000002fc cmpq         $-1, %r14
+	0x0f, 0x85, 0x7a, 0x01, 0x00, 0x00, //0x00000300 jne          LBB0_61
+	0x48, 0xff, 0xcf, //0x00000306 decq         %rdi
+	0x49, 0x89, 0xfe, //0x00000309 movq         %rdi, %r14
+	0xe9, 0x9f, 0xff, 0xff, 0xff, //0x0000030c jmp          LBB0_40
+	//0x00000311 LBB0_34
+	0x48, 0x89, 0xd7, //0x00000311 movq         %rdx, %rdi
+	0x4c, 0x29, 0xff, //0x00000314 subq         %r15, %rdi
+	0x49, 0x83, 0xfa, 0xff, //0x00000317 cmpq         $-1, %r10
+	0x0f, 0x85, 0x5f, 0x01, 0x00, 0x00, //0x0000031b jne          LBB0_61
+	0x48, 0xff, 0xcf, //0x00000321 decq         %rdi
+	0x49, 0x89, 0xfa, //0x00000324 movq         %rdi, %r10
+	0xe9, 0x84, 0xff, 0xff, 0xff, //0x00000327 jmp          LBB0_40
+	//0x0000032c LBB0_60
+	0x48, 0x01, 0xcb, //0x0000032c addq         %rcx, %rbx
+	0x49, 0x89, 0xdc, //0x0000032f movq         %rbx, %r12
+	0x48, 0x8b, 0x75, 0xc0, //0x00000332 movq         $-64(%rbp), %rsi
+	0x48, 0x8b, 0x5d, 0xc8, //0x00000336 movq         $-56(%rbp), %rbx
+	//0x0000033a LBB0_42
+	0x48, 0xc7, 0xc7, 0xff, 0xff, 0xff, 0xff, //0x0000033a movq         $-1, %rdi
+	0x4d, 0x85, 0xf6, //0x00000341 testq        %r14, %r14
+	0x0f, 0x84, 0x14, 0x01, 0x00, 0x00, //0x00000344 je           LBB0_57
+	//0x0000034a LBB0_43
+	0x4d, 0x85, 0xdb, //0x0000034a testq        %r11, %r11
+	0x0f, 0x84, 0x0b, 0x01, 0x00, 0x00, //0x0000034d je           LBB0_57
+	0x4d, 0x85, 0xd2, //0x00000353 testq        %r10, %r10
+	0x48, 0x8b, 0x55, 0xd0, //0x00000356 movq         $-48(%rbp), %rdx
+	0x0f, 0x84, 0xfe, 0x00, 0x00, 0x00, //0x0000035a je           LBB0_57
+	0x4d, 0x29, 0xfc, //0x00000360 subq         %r15, %r12
+	0x49, 0x8d, 0x44, 0x24, 0xff, //0x00000363 leaq         $-1(%r12), %rax
+	0x49, 0x39, 0xc6, //0x00000368 cmpq         %rax, %r14
+	0x0f, 0x84, 0x3c, 0x00, 0x00, 0x00, //0x0000036b je           LBB0_48
+	0x49, 0x39, 0xc2, //0x00000371 cmpq         %rax, %r10
+	0x0f, 0x84, 0x33, 0x00, 0x00, 0x00, //0x00000374 je           LBB0_48
+	0x49, 0x39, 0xc3, //0x0000037a cmpq         %rax, %r11
+	0x0f, 0x84, 0x2a, 0x00, 0x00, 0x00, //0x0000037d je           LBB0_48
+	0x4d, 0x85, 0xdb, //0x00000383 testq        %r11, %r11
+	0x0f, 0x8e, 0x35, 0x00, 0x00, 0x00, //0x00000386 jle          LBB0_52
+	0x49, 0x8d, 0x43, 0xff, //0x0000038c leaq         $-1(%r11), %rax
+	0x49, 0x39, 0xc6, //0x00000390 cmpq         %rax, %r14
+	0x0f, 0x84, 0x28, 0x00, 0x00, 0x00, //0x00000393 je           LBB0_52
+	0x49, 0xf7, 0xd3, //0x00000399 notq         %r11
+	0x4c, 0x89, 0xdf, //0x0000039c movq         %r11, %rdi
+	0x48, 0x85, 0xff, //0x0000039f testq        %rdi, %rdi
+	0x0f, 0x89, 0x98, 0x00, 0x00, 0x00, //0x000003a2 jns          LBB0_58
+	0xe9, 0xb1, 0x00, 0x00, 0x00, //0x000003a8 jmp          LBB0_57
+	//0x000003ad LBB0_48
+	0x49, 0xf7, 0xdc, //0x000003ad negq         %r12
+	0x4c, 0x89, 0xe7, //0x000003b0 movq         %r12, %rdi
+	0x48, 0x85, 0xff, //0x000003b3 testq        %rdi, %rdi
+	0x0f, 0x89, 0x84, 0x00, 0x00, 0x00, //0x000003b6 jns          LBB0_58
+	0xe9, 0x9d, 0x00, 0x00, 0x00, //0x000003bc jmp          LBB0_57
+	//0x000003c1 LBB0_52
+	0x4c, 0x89, 0xd0, //0x000003c1 movq         %r10, %rax
+	0x4c, 0x09, 0xf0, //0x000003c4 orq          %r14, %rax
+	0x4d, 0x39, 0xf2, //0x000003c7 cmpq         %r14, %r10
+	0x0f, 0x8c, 0x1d, 0x00, 0x00, 0x00, //0x000003ca jl           LBB0_55
+	0x48, 0x85, 0xc0, //0x000003d0 testq        %rax, %rax
+	0x0f, 0x88, 0x14, 0x00, 0x00, 0x00, //0x000003d3 js           LBB0_55
+	0x49, 0xf7, 0xd2, //0x000003d9 notq         %r10
+	0x4c, 0x89, 0xd7, //0x000003dc movq         %r10, %rdi
+	0x48, 0x85, 0xff, //0x000003df testq        %rdi, %rdi
+	0x0f, 0x89, 0x58, 0x00, 0x00, 0x00, //0x000003e2 jns          LBB0_58
+	0xe9, 0x71, 0x00, 0x00, 0x00, //0x000003e8 jmp          LBB0_57
+	//0x000003ed LBB0_55
+	0x48, 0x85, 0xc0, //0x000003ed testq        %rax, %rax
+	0x49, 0x8d, 0x46, 0xff, //0x000003f0 leaq         $-1(%r14), %rax
+	0x49, 0xf7, 0xd6, //0x000003f4 notq         %r14
+	0x4d, 0x0f, 0x48, 0xf4, //0x000003f7 cmovsq       %r12, %r14
+	0x49, 0x39, 0xc2, //0x000003fb cmpq         %rax, %r10
+	0x4d, 0x0f, 0x45, 0xf4, //0x000003fe cmovneq      %r12, %r14
+	0x4c, 0x89, 0xf7, //0x00000402 movq         %r14, %rdi
+	0x48, 0x85, 0xff, //0x00000405 testq        %rdi, %rdi
+	0x0f, 0x89, 0x32, 0x00, 0x00, 0x00, //0x00000408 jns          LBB0_58
+	0xe9, 0x4b, 0x00, 0x00, 0x00, //0x0000040e jmp          LBB0_57
+	//0x00000413 LBB0_17
+	0x4c, 0x29, 0xfb, //0x00000413 subq         %r15, %rbx
+	0x0f, 0xbc, 0xfa, //0x00000416 bsfl         %edx, %edi
+	0xe9, 0x07, 0x00, 0x00, 0x00, //0x00000419 jmp          LBB0_14
+	//0x0000041e LBB0_13
+	0x4c, 0x29, 0xfb, //0x0000041e subq         %r15, %rbx
+	0x41, 0x0f, 0xbc, 0xf9, //0x00000421 bsfl         %r9d, %edi
+	//0x00000425 LBB0_14
+	0x48, 0x01, 0xdf, //0x00000425 addq         %rbx, %rdi
+	//0x00000428 LBB0_15
+	0x48, 0xf7, 0xd7, //0x00000428 notq         %rdi
+	0x48, 0x8b, 0x75, 0xc0, //0x0000042b movq         $-64(%rbp), %rsi
+	0x48, 0x8b, 0x5d, 0xc8, //0x0000042f movq         $-56(%rbp), %rbx
+	0x48, 0x8b, 0x55, 0xd0, //0x00000433 movq         $-48(%rbp), %rdx
+	0x48, 0x85, 0xff, //0x00000437 testq        %rdi, %rdi
+	0x0f, 0x88, 0x1e, 0x00, 0x00, 0x00, //0x0000043a js           LBB0_57
+	//0x00000440 LBB0_58
+	0x49, 0x01, 0xff, //0x00000440 addq         %rdi, %r15
+	0x48, 0x89, 0xd0, //0x00000443 movq         %rdx, %rax
+	0xe9, 0x20, 0x00, 0x00, 0x00, //0x00000446 jmp          LBB0_59
+	//0x0000044b LBB0_41
+	0x49, 0x89, 0xc4, //0x0000044b movq         %rax, %r12
+	0x48, 0xc7, 0xc7, 0xff, 0xff, 0xff, 0xff, //0x0000044e movq         $-1, %rdi
+	0x4d, 0x85, 0xf6, //0x00000455 testq        %r14, %r14
+	0x0f, 0x85, 0xec, 0xfe, 0xff, 0xff, //0x00000458 jne          LBB0_43
+	//0x0000045e LBB0_57
+	0x48, 0xf7, 0xd7, //0x0000045e notq         %rdi
+	0x49, 0x01, 0xff, //0x00000461 addq         %rdi, %r15
+	0x48, 0xc7, 0xc0, 0xfe, 0xff, 0xff, 0xff, //0x00000464 movq         $-2, %rax
+	//0x0000046b LBB0_59
+	0x49, 0x29, 0xdf, //0x0000046b subq         %rbx, %r15
+	0x4c, 0x89, 0x3e, //0x0000046e movq         %r15, (%rsi)
+	0x48, 0x83, 0xc4, 0x18, //0x00000471 addq         $24, %rsp
+	0x5b, //0x00000475 popq         %rbx
+	0x41, 0x5c, //0x00000476 popq         %r12
+	0x41, 0x5d, //0x00000478 popq         %r13
+	0x41, 0x5e, //0x0000047a popq         %r14
+	0x41, 0x5f, //0x0000047c popq         %r15
+	0x5d, //0x0000047e popq         %rbp
+	0xc3, //0x0000047f retq         
+	//0x00000480 LBB0_61
+	0x48, 0xf7, 0xdf, //0x00000480 negq         %rdi
+	0x48, 0x8b, 0x55, 0xd0, //0x00000483 movq         $-48(%rbp), %rdx
+	0x48, 0x85, 0xff, //0x00000487 testq        %rdi, %rdi
+	0x0f, 0x89, 0xb0, 0xff, 0xff, 0xff, //0x0000048a jns          LBB0_58
+	0xe9, 0xc9, 0xff, 0xff, 0xff, //0x00000490 jmp          LBB0_57
+	//0x00000495 LBB0_1
+	0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000495 movq         $-1, %rax
+	0xe9, 0xca, 0xff, 0xff, 0xff, //0x0000049c jmp          LBB0_59
+	//0x000004a1 LBB0_8
+	0x49, 0xc7, 0xc2, 0xff, 0xff, 0xff, 0xff, //0x000004a1 movq         $-1, %r10
+	0x4d, 0x89, 0xfc, //0x000004a8 movq         %r15, %r12
+	0x4d, 0x89, 0xe8, //0x000004ab movq         %r13, %r8
+	0x49, 0xc7, 0xc6, 0xff, 0xff, 0xff, 0xff, //0x000004ae movq         $-1, %r14
+	0x49, 0xc7, 0xc3, 0xff, 0xff, 0xff, 0xff, //0x000004b5 movq         $-1, %r11
+	0xe9, 0xdc, 0xfd, 0xff, 0xff, //0x000004bc jmp          LBB0_31
+	0x90, 0x90, 0x90, //0x000004c1 .p2align 2, 0x90
+	// // .set L0_0_set_38, LBB0_38-LJTI0_0
+	// // .set L0_0_set_42, LBB0_42-LJTI0_0
+	// // .set L0_0_set_34, LBB0_34-LJTI0_0
+	// // .set L0_0_set_40, LBB0_40-LJTI0_0
+	// // .set L0_0_set_36, LBB0_36-LJTI0_0
+	//0x000004c4 LJTI0_0
+	0x17, 0xfe, 0xff, 0xff, //0x000004c4 .long L0_0_set_38
+	0x76, 0xfe, 0xff, 0xff, //0x000004c8 .long L0_0_set_42
+	0x17, 0xfe, 0xff, 0xff, //0x000004cc .long L0_0_set_38
+	0x4d, 0xfe, 0xff, 0xff, //0x000004d0 .long L0_0_set_34
+	0x76, 0xfe, 0xff, 0xff, //0x000004d4 .long L0_0_set_42
+	0xec, 0xfd, 0xff, 0xff, //0x000004d8 .long L0_0_set_40
+	0xec, 0xfd, 0xff, 0xff, //0x000004dc .long L0_0_set_40
+	0xec, 0xfd, 0xff, 0xff, //0x000004e0 .long L0_0_set_40
+	0xec, 0xfd, 0xff, 0xff, //0x000004e4 .long L0_0_set_40
+	0xec, 0xfd, 0xff, 0xff, //0x000004e8 .long L0_0_set_40
+	0xec, 0xfd, 0xff, 0xff, //0x000004ec .long L0_0_set_40
+	0xec, 0xfd, 0xff, 0xff, //0x000004f0 .long L0_0_set_40
+	0xec, 0xfd, 0xff, 0xff, //0x000004f4 .long L0_0_set_40
+	0xec, 0xfd, 0xff, 0xff, //0x000004f8 .long L0_0_set_40
+	0xec, 0xfd, 0xff, 0xff, //0x000004fc .long L0_0_set_40
+	0x76, 0xfe, 0xff, 0xff, //0x00000500 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000504 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000508 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x0000050c .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000510 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000514 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000518 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x0000051c .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000520 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000524 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000528 .long L0_0_set_42
+	0x32, 0xfe, 0xff, 0xff, //0x0000052c .long L0_0_set_36
+	0x76, 0xfe, 0xff, 0xff, //0x00000530 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000534 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000538 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x0000053c .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000540 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000544 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000548 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x0000054c .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000550 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000554 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000558 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x0000055c .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000560 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000564 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000568 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x0000056c .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000570 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000574 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000578 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x0000057c .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000580 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000584 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000588 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x0000058c .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000590 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000594 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x00000598 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x0000059c .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x000005a0 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x000005a4 .long L0_0_set_42
+	0x76, 0xfe, 0xff, 0xff, //0x000005a8 .long L0_0_set_42
+	0x32, 0xfe, 0xff, 0xff, //0x000005ac .long L0_0_set_36
+	//0x000005b0 .p2align 2, 0x00
+	//0x000005b0 _MASK_USE_NUMBER
+	0x02, 0x00, 0x00, 0x00, //0x000005b0 .long 2
+}
+ 

vendor/github.com/bytedance/sonic/internal/native/avx/skip_object.go

@@ -0,0 +1,37 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the     License    );
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an     AS IS     BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_skip_object func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+var S_skip_object uintptr
+
+//go:nosplit
+func skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return F_skip_object(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}

vendor/github.com/bytedance/sonic/internal/native/avx/skip_object_subr.go

@@ -0,0 +1,46 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__skip_object = 160
+)
+
+const (
+    _stack__skip_object = 152
+)
+
+const (
+    _size__skip_object = 9524
+)
+
+var (
+    _pcsp__skip_object = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {8962, 152},
+        {8966, 48},
+        {8967, 40},
+        {8969, 32},
+        {8971, 24},
+        {8973, 16},
+        {8975, 8},
+        {8976, 0},
+        {9524, 152},
+    }
+)
+
+var _cfunc_skip_object = []loader.CFunc{
+    {"_skip_object_entry", 0,  _entry__skip_object, 0, nil},
+    {"_skip_object", _entry__skip_object, _size__skip_object, _stack__skip_object, _pcsp__skip_object},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/skip_one.go

@@ -0,0 +1,37 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var  F_skip_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+var S_skip_one uintptr
+
+//go:nosplit
+func skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return F_skip_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}

vendor/github.com/bytedance/sonic/internal/native/avx/skip_one_fast.go

@@ -0,0 +1,37 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_skip_one_fast func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
+
+var S_skip_one_fast uintptr
+
+//go:nosplit
+func skip_one_fast(s *string, p *int) (ret int) {
+    return F_skip_one_fast(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}
+

vendor/github.com/bytedance/sonic/internal/native/avx/skip_one_fast_subr.go

@@ -0,0 +1,45 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__skip_one_fast = 128
+)
+
+const (
+    _stack__skip_one_fast = 176
+)
+
+const (
+    _size__skip_one_fast = 3016
+)
+
+var (
+    _pcsp__skip_one_fast = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {658, 176},
+        {659, 168},
+        {661, 160},
+        {663, 152},
+        {665, 144},
+        {667, 136},
+        {671, 128},
+        {3016, 176},
+    }
+)
+
+var _cfunc_skip_one_fast = []loader.CFunc{
+    {"_skip_one_fast_entry", 0,  _entry__skip_one_fast, 0, nil},
+    {"_skip_one_fast", _entry__skip_one_fast, _size__skip_one_fast, _stack__skip_one_fast, _pcsp__skip_one_fast},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/skip_one_fast_text_amd64.go

@@ -0,0 +1,945 @@
+// +build amd64
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+var _text_skip_one_fast = []byte{
+	// .p2align 4, 0x00
+	// LCPI0_0
+	0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, // QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c  // .space 16, ',,,,,,,,,,,,,,,,'
+	//0x00000010 LCPI0_1
+	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //0x00000010 QUAD $0x2020202020202020; QUAD $0x2020202020202020  // .space 16, '                '
+	//0x00000020 LCPI0_2
+	0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, //0x00000020 QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d  // .space 16, '}}}}}}}}}}}}}}}}'
+	//0x00000030 LCPI0_3
+	0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, //0x00000030 QUAD $0x2222222222222222; QUAD $0x2222222222222222  // .space 16, '""""""""""""""""'
+	//0x00000040 LCPI0_4
+	0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, //0x00000040 QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c  // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+	//0x00000050 LCPI0_5
+	0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, //0x00000050 QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b  // .space 16, '{{{{{{{{{{{{{{{{'
+	//0x00000060 LCPI0_6
+	0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, //0x00000060 QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b  // .space 16, '[[[[[[[[[[[[[[[['
+	//0x00000070 LCPI0_7
+	0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, //0x00000070 QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d  // .space 16, ']]]]]]]]]]]]]]]]'
+	//0x00000080 .p2align 4, 0x90
+	//0x00000080 _skip_one_fast
+	0x55, //0x00000080 pushq        %rbp
+	0x48, 0x89, 0xe5, //0x00000081 movq         %rsp, %rbp
+	0x41, 0x57, //0x00000084 pushq        %r15
+	0x41, 0x56, //0x00000086 pushq        %r14
+	0x41, 0x55, //0x00000088 pushq        %r13
+	0x41, 0x54, //0x0000008a pushq        %r12
+	0x53, //0x0000008c pushq        %rbx
+	0x48, 0x81, 0xec, 0x80, 0x00, 0x00, 0x00, //0x0000008d subq         $128, %rsp
+	0x4c, 0x8b, 0x37, //0x00000094 movq         (%rdi), %r14
+	0x4c, 0x8b, 0x47, 0x08, //0x00000097 movq         $8(%rdi), %r8
+	0x48, 0x8b, 0x16, //0x0000009b movq         (%rsi), %rdx
+	0x48, 0x89, 0xd0, //0x0000009e movq         %rdx, %rax
+	0x4c, 0x29, 0xc0, //0x000000a1 subq         %r8, %rax
+	0x0f, 0x83, 0x2a, 0x00, 0x00, 0x00, //0x000000a4 jae          LBB0_5
+	0x41, 0x8a, 0x0c, 0x16, //0x000000aa movb         (%r14,%rdx), %cl
+	0x80, 0xf9, 0x0d, //0x000000ae cmpb         $13, %cl
+	0x0f, 0x84, 0x1d, 0x00, 0x00, 0x00, //0x000000b1 je           LBB0_5
+	0x80, 0xf9, 0x20, //0x000000b7 cmpb         $32, %cl
+	0x0f, 0x84, 0x14, 0x00, 0x00, 0x00, //0x000000ba je           LBB0_5
+	0x80, 0xc1, 0xf7, //0x000000c0 addb         $-9, %cl
+	0x80, 0xf9, 0x01, //0x000000c3 cmpb         $1, %cl
+	0x0f, 0x86, 0x08, 0x00, 0x00, 0x00, //0x000000c6 jbe          LBB0_5
+	0x49, 0x89, 0xd3, //0x000000cc movq         %rdx, %r11
+	0xe9, 0x2b, 0x01, 0x00, 0x00, //0x000000cf jmp          LBB0_27
+	//0x000000d4 LBB0_5
+	0x4c, 0x8d, 0x5a, 0x01, //0x000000d4 leaq         $1(%rdx), %r11
+	0x4d, 0x39, 0xc3, //0x000000d8 cmpq         %r8, %r11
+	0x0f, 0x83, 0x22, 0x00, 0x00, 0x00, //0x000000db jae          LBB0_9
+	0x43, 0x8a, 0x0c, 0x1e, //0x000000e1 movb         (%r14,%r11), %cl
+	0x80, 0xf9, 0x0d, //0x000000e5 cmpb         $13, %cl
+	0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x000000e8 je           LBB0_9
+	0x80, 0xf9, 0x20, //0x000000ee cmpb         $32, %cl
+	0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x000000f1 je           LBB0_9
+	0x80, 0xc1, 0xf7, //0x000000f7 addb         $-9, %cl
+	0x80, 0xf9, 0x01, //0x000000fa cmpb         $1, %cl
+	0x0f, 0x87, 0xfc, 0x00, 0x00, 0x00, //0x000000fd ja           LBB0_27
+	//0x00000103 LBB0_9
+	0x4c, 0x8d, 0x5a, 0x02, //0x00000103 leaq         $2(%rdx), %r11
+	0x4d, 0x39, 0xc3, //0x00000107 cmpq         %r8, %r11
+	0x0f, 0x83, 0x22, 0x00, 0x00, 0x00, //0x0000010a jae          LBB0_13
+	0x43, 0x8a, 0x0c, 0x1e, //0x00000110 movb         (%r14,%r11), %cl
+	0x80, 0xf9, 0x0d, //0x00000114 cmpb         $13, %cl
+	0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x00000117 je           LBB0_13
+	0x80, 0xf9, 0x20, //0x0000011d cmpb         $32, %cl
+	0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x00000120 je           LBB0_13
+	0x80, 0xc1, 0xf7, //0x00000126 addb         $-9, %cl
+	0x80, 0xf9, 0x01, //0x00000129 cmpb         $1, %cl
+	0x0f, 0x87, 0xcd, 0x00, 0x00, 0x00, //0x0000012c ja           LBB0_27
+	//0x00000132 LBB0_13
+	0x4c, 0x8d, 0x5a, 0x03, //0x00000132 leaq         $3(%rdx), %r11
+	0x4d, 0x39, 0xc3, //0x00000136 cmpq         %r8, %r11
+	0x0f, 0x83, 0x22, 0x00, 0x00, 0x00, //0x00000139 jae          LBB0_17
+	0x43, 0x8a, 0x0c, 0x1e, //0x0000013f movb         (%r14,%r11), %cl
+	0x80, 0xf9, 0x0d, //0x00000143 cmpb         $13, %cl
+	0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x00000146 je           LBB0_17
+	0x80, 0xf9, 0x20, //0x0000014c cmpb         $32, %cl
+	0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x0000014f je           LBB0_17
+	0x80, 0xc1, 0xf7, //0x00000155 addb         $-9, %cl
+	0x80, 0xf9, 0x01, //0x00000158 cmpb         $1, %cl
+	0x0f, 0x87, 0x9e, 0x00, 0x00, 0x00, //0x0000015b ja           LBB0_27
+	//0x00000161 LBB0_17
+	0x48, 0x8d, 0x4a, 0x04, //0x00000161 leaq         $4(%rdx), %rcx
+	0x49, 0x39, 0xc8, //0x00000165 cmpq         %rcx, %r8
+	0x0f, 0x86, 0x4b, 0x00, 0x00, 0x00, //0x00000168 jbe          LBB0_23
+	0x49, 0x39, 0xc8, //0x0000016e cmpq         %rcx, %r8
+	0x0f, 0x84, 0x51, 0x00, 0x00, 0x00, //0x00000171 je           LBB0_24
+	0x4b, 0x8d, 0x0c, 0x06, //0x00000177 leaq         (%r14,%r8), %rcx
+	0x48, 0x83, 0xc0, 0x04, //0x0000017b addq         $4, %rax
+	0x4e, 0x8d, 0x5c, 0x32, 0x05, //0x0000017f leaq         $5(%rdx,%r14), %r11
+	0x48, 0xba, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x00000184 movabsq      $4294977024, %rdx
+	0x90, 0x90, //0x0000018e .p2align 4, 0x90
+	//0x00000190 LBB0_20
+	0x41, 0x0f, 0xbe, 0x5b, 0xff, //0x00000190 movsbl       $-1(%r11), %ebx
+	0x83, 0xfb, 0x20, //0x00000195 cmpl         $32, %ebx
+	0x0f, 0x87, 0x48, 0x00, 0x00, 0x00, //0x00000198 ja           LBB0_26
+	0x48, 0x0f, 0xa3, 0xda, //0x0000019e btq          %rbx, %rdx
+	0x0f, 0x83, 0x3e, 0x00, 0x00, 0x00, //0x000001a2 jae          LBB0_26
+	0x49, 0xff, 0xc3, //0x000001a8 incq         %r11
+	0x48, 0xff, 0xc0, //0x000001ab incq         %rax
+	0x0f, 0x85, 0xdc, 0xff, 0xff, 0xff, //0x000001ae jne          LBB0_20
+	0xe9, 0x12, 0x00, 0x00, 0x00, //0x000001b4 jmp          LBB0_25
+	//0x000001b9 LBB0_23
+	0x48, 0x89, 0x0e, //0x000001b9 movq         %rcx, (%rsi)
+	0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x000001bc movq         $-1, %rax
+	0xe9, 0x46, 0x01, 0x00, 0x00, //0x000001c3 jmp          LBB0_45
+	//0x000001c8 LBB0_24
+	0x4c, 0x01, 0xf1, //0x000001c8 addq         %r14, %rcx
+	//0x000001cb LBB0_25
+	0x4c, 0x29, 0xf1, //0x000001cb subq         %r14, %rcx
+	0x49, 0x89, 0xcb, //0x000001ce movq         %rcx, %r11
+	0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x000001d1 movq         $-1, %rax
+	0x4d, 0x39, 0xc3, //0x000001d8 cmpq         %r8, %r11
+	0x0f, 0x82, 0x1e, 0x00, 0x00, 0x00, //0x000001db jb           LBB0_27
+	0xe9, 0x28, 0x01, 0x00, 0x00, //0x000001e1 jmp          LBB0_45
+	//0x000001e6 LBB0_26
+	0x4c, 0x89, 0xf0, //0x000001e6 movq         %r14, %rax
+	0x48, 0xf7, 0xd0, //0x000001e9 notq         %rax
+	0x49, 0x01, 0xc3, //0x000001ec addq         %rax, %r11
+	0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x000001ef movq         $-1, %rax
+	0x4d, 0x39, 0xc3, //0x000001f6 cmpq         %r8, %r11
+	0x0f, 0x83, 0x0f, 0x01, 0x00, 0x00, //0x000001f9 jae          LBB0_45
+	//0x000001ff LBB0_27
+	0x49, 0x8d, 0x5b, 0x01, //0x000001ff leaq         $1(%r11), %rbx
+	0x48, 0x89, 0x1e, //0x00000203 movq         %rbx, (%rsi)
+	0x43, 0x0f, 0xbe, 0x0c, 0x1e, //0x00000206 movsbl       (%r14,%r11), %ecx
+	0x83, 0xf9, 0x7b, //0x0000020b cmpl         $123, %ecx
+	0x0f, 0x87, 0x1f, 0x01, 0x00, 0x00, //0x0000020e ja           LBB0_47
+	0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000214 movq         $-1, %rax
+	0x48, 0x8d, 0x15, 0x26, 0x0a, 0x00, 0x00, //0x0000021b leaq         $2598(%rip), %rdx  /* LJTI0_0+0(%rip) */
+	0x48, 0x63, 0x0c, 0x8a, //0x00000222 movslq       (%rdx,%rcx,4), %rcx
+	0x48, 0x01, 0xd1, //0x00000226 addq         %rdx, %rcx
+	0xff, 0xe1, //0x00000229 jmpq         *%rcx
+	//0x0000022b LBB0_29
+	0x48, 0x8b, 0x4f, 0x08, //0x0000022b movq         $8(%rdi), %rcx
+	0x48, 0x89, 0xc8, //0x0000022f movq         %rcx, %rax
+	0x48, 0x29, 0xd8, //0x00000232 subq         %rbx, %rax
+	0x4c, 0x01, 0xf3, //0x00000235 addq         %r14, %rbx
+	0x48, 0x83, 0xf8, 0x10, //0x00000238 cmpq         $16, %rax
+	0x0f, 0x82, 0x77, 0x00, 0x00, 0x00, //0x0000023c jb           LBB0_34
+	0x4c, 0x29, 0xd9, //0x00000242 subq         %r11, %rcx
+	0x48, 0x83, 0xc1, 0xef, //0x00000245 addq         $-17, %rcx
+	0x48, 0x89, 0xca, //0x00000249 movq         %rcx, %rdx
+	0x48, 0x83, 0xe2, 0xf0, //0x0000024c andq         $-16, %rdx
+	0x4c, 0x01, 0xda, //0x00000250 addq         %r11, %rdx
+	0x49, 0x8d, 0x54, 0x16, 0x11, //0x00000253 leaq         $17(%r14,%rdx), %rdx
+	0x83, 0xe1, 0x0f, //0x00000258 andl         $15, %ecx
+	0xc5, 0xfa, 0x6f, 0x05, 0x9d, 0xfd, 0xff, 0xff, //0x0000025b vmovdqu      $-611(%rip), %xmm0  /* LCPI0_0+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x0d, 0xa5, 0xfd, 0xff, 0xff, //0x00000263 vmovdqu      $-603(%rip), %xmm1  /* LCPI0_1+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x15, 0xad, 0xfd, 0xff, 0xff, //0x0000026b vmovdqu      $-595(%rip), %xmm2  /* LCPI0_2+0(%rip) */
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000273 .p2align 4, 0x90
+	//0x00000280 LBB0_31
+	0xc5, 0xfa, 0x6f, 0x1b, //0x00000280 vmovdqu      (%rbx), %xmm3
+	0xc5, 0xe1, 0x74, 0xe0, //0x00000284 vpcmpeqb     %xmm0, %xmm3, %xmm4
+	0xc5, 0xe1, 0xeb, 0xd9, //0x00000288 vpor         %xmm1, %xmm3, %xmm3
+	0xc5, 0xe1, 0x74, 0xda, //0x0000028c vpcmpeqb     %xmm2, %xmm3, %xmm3
+	0xc5, 0xe1, 0xeb, 0xdc, //0x00000290 vpor         %xmm4, %xmm3, %xmm3
+	0xc5, 0xf9, 0xd7, 0xfb, //0x00000294 vpmovmskb    %xmm3, %edi
+	0x66, 0x85, 0xff, //0x00000298 testw        %di, %di
+	0x0f, 0x85, 0x5a, 0x00, 0x00, 0x00, //0x0000029b jne          LBB0_42
+	0x48, 0x83, 0xc3, 0x10, //0x000002a1 addq         $16, %rbx
+	0x48, 0x83, 0xc0, 0xf0, //0x000002a5 addq         $-16, %rax
+	0x48, 0x83, 0xf8, 0x0f, //0x000002a9 cmpq         $15, %rax
+	0x0f, 0x87, 0xcd, 0xff, 0xff, 0xff, //0x000002ad ja           LBB0_31
+	0x48, 0x89, 0xc8, //0x000002b3 movq         %rcx, %rax
+	0x48, 0x89, 0xd3, //0x000002b6 movq         %rdx, %rbx
+	//0x000002b9 LBB0_34
+	0x48, 0x85, 0xc0, //0x000002b9 testq        %rax, %rax
+	0x0f, 0x84, 0x31, 0x00, 0x00, 0x00, //0x000002bc je           LBB0_41
+	0x48, 0x8d, 0x0c, 0x03, //0x000002c2 leaq         (%rbx,%rax), %rcx
+	//0x000002c6 LBB0_36
+	0x0f, 0xb6, 0x13, //0x000002c6 movzbl       (%rbx), %edx
+	0x80, 0xfa, 0x2c, //0x000002c9 cmpb         $44, %dl
+	0x0f, 0x84, 0x21, 0x00, 0x00, 0x00, //0x000002cc je           LBB0_41
+	0x80, 0xfa, 0x7d, //0x000002d2 cmpb         $125, %dl
+	0x0f, 0x84, 0x18, 0x00, 0x00, 0x00, //0x000002d5 je           LBB0_41
+	0x80, 0xfa, 0x5d, //0x000002db cmpb         $93, %dl
+	0x0f, 0x84, 0x0f, 0x00, 0x00, 0x00, //0x000002de je           LBB0_41
+	0x48, 0xff, 0xc3, //0x000002e4 incq         %rbx
+	0x48, 0xff, 0xc8, //0x000002e7 decq         %rax
+	0x0f, 0x85, 0xd6, 0xff, 0xff, 0xff, //0x000002ea jne          LBB0_36
+	0x48, 0x89, 0xcb, //0x000002f0 movq         %rcx, %rbx
+	//0x000002f3 LBB0_41
+	0x4c, 0x29, 0xf3, //0x000002f3 subq         %r14, %rbx
+	0xe9, 0x0d, 0x00, 0x00, 0x00, //0x000002f6 jmp          LBB0_43
+	//0x000002fb LBB0_42
+	0x0f, 0xb7, 0xc7, //0x000002fb movzwl       %di, %eax
+	0x48, 0x0f, 0xbc, 0xc0, //0x000002fe bsfq         %rax, %rax
+	0x4c, 0x29, 0xf3, //0x00000302 subq         %r14, %rbx
+	0x48, 0x01, 0xc3, //0x00000305 addq         %rax, %rbx
+	//0x00000308 LBB0_43
+	0x48, 0x89, 0x1e, //0x00000308 movq         %rbx, (%rsi)
+	//0x0000030b LBB0_44
+	0x4c, 0x89, 0xd8, //0x0000030b movq         %r11, %rax
+	//0x0000030e LBB0_45
+	0x48, 0x8d, 0x65, 0xd8, //0x0000030e leaq         $-40(%rbp), %rsp
+	0x5b, //0x00000312 popq         %rbx
+	0x41, 0x5c, //0x00000313 popq         %r12
+	0x41, 0x5d, //0x00000315 popq         %r13
+	0x41, 0x5e, //0x00000317 popq         %r14
+	0x41, 0x5f, //0x00000319 popq         %r15
+	0x5d, //0x0000031b popq         %rbp
+	0xc5, 0xf8, 0x77, //0x0000031c vzeroupper   
+	0xc3, //0x0000031f retq         
+	//0x00000320 LBB0_46
+	0x49, 0x8d, 0x4b, 0x04, //0x00000320 leaq         $4(%r11), %rcx
+	0x48, 0x3b, 0x4f, 0x08, //0x00000324 cmpq         $8(%rdi), %rcx
+	0x0f, 0x87, 0xe0, 0xff, 0xff, 0xff, //0x00000328 ja           LBB0_45
+	0xe9, 0xa6, 0x04, 0x00, 0x00, //0x0000032e jmp          LBB0_83
+	//0x00000333 LBB0_47
+	0x4c, 0x89, 0x1e, //0x00000333 movq         %r11, (%rsi)
+	0x48, 0xc7, 0xc0, 0xfe, 0xff, 0xff, 0xff, //0x00000336 movq         $-2, %rax
+	0xe9, 0xcc, 0xff, 0xff, 0xff, //0x0000033d jmp          LBB0_45
+	//0x00000342 LBB0_48
+	0x4c, 0x8b, 0x47, 0x08, //0x00000342 movq         $8(%rdi), %r8
+	0x4d, 0x89, 0xc7, //0x00000346 movq         %r8, %r15
+	0x49, 0x29, 0xdf, //0x00000349 subq         %rbx, %r15
+	0x49, 0x83, 0xff, 0x20, //0x0000034c cmpq         $32, %r15
+	0x0f, 0x8c, 0xbb, 0x08, 0x00, 0x00, //0x00000350 jl           LBB0_117
+	0x41, 0xb9, 0xff, 0xff, 0xff, 0xff, //0x00000356 movl         $4294967295, %r9d
+	0x4f, 0x8d, 0x14, 0x1e, //0x0000035c leaq         (%r14,%r11), %r10
+	0x4d, 0x29, 0xd8, //0x00000360 subq         %r11, %r8
+	0x41, 0xbd, 0x1f, 0x00, 0x00, 0x00, //0x00000363 movl         $31, %r13d
+	0x45, 0x31, 0xff, //0x00000369 xorl         %r15d, %r15d
+	0xc5, 0xfa, 0x6f, 0x05, 0xbc, 0xfc, 0xff, 0xff, //0x0000036c vmovdqu      $-836(%rip), %xmm0  /* LCPI0_3+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x0d, 0xc4, 0xfc, 0xff, 0xff, //0x00000374 vmovdqu      $-828(%rip), %xmm1  /* LCPI0_4+0(%rip) */
+	0x45, 0x31, 0xe4, //0x0000037c xorl         %r12d, %r12d
+	0xe9, 0x2e, 0x00, 0x00, 0x00, //0x0000037f jmp          LBB0_50
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000384 .p2align 4, 0x90
+	//0x00000390 LBB0_52
+	0x45, 0x31, 0xe4, //0x00000390 xorl         %r12d, %r12d
+	0x85, 0xc9, //0x00000393 testl        %ecx, %ecx
+	0x0f, 0x85, 0x9e, 0x00, 0x00, 0x00, //0x00000395 jne          LBB0_110
+	//0x0000039b LBB0_53
+	0x49, 0x83, 0xc7, 0x20, //0x0000039b addq         $32, %r15
+	0x4b, 0x8d, 0x4c, 0x28, 0xe0, //0x0000039f leaq         $-32(%r8,%r13), %rcx
+	0x49, 0x83, 0xc5, 0xe0, //0x000003a4 addq         $-32, %r13
+	0x48, 0x83, 0xf9, 0x3f, //0x000003a8 cmpq         $63, %rcx
+	0x0f, 0x8e, 0xdc, 0x07, 0x00, 0x00, //0x000003ac jle          LBB0_54
+	//0x000003b2 LBB0_50
+	0xc4, 0x81, 0x7a, 0x6f, 0x54, 0x3a, 0x01, //0x000003b2 vmovdqu      $1(%r10,%r15), %xmm2
+	0xc4, 0x81, 0x7a, 0x6f, 0x5c, 0x3a, 0x11, //0x000003b9 vmovdqu      $17(%r10,%r15), %xmm3
+	0xc5, 0xe9, 0x74, 0xe0, //0x000003c0 vpcmpeqb     %xmm0, %xmm2, %xmm4
+	0xc5, 0xf9, 0xd7, 0xfc, //0x000003c4 vpmovmskb    %xmm4, %edi
+	0xc5, 0xe1, 0x74, 0xe0, //0x000003c8 vpcmpeqb     %xmm0, %xmm3, %xmm4
+	0xc5, 0xf9, 0xd7, 0xcc, //0x000003cc vpmovmskb    %xmm4, %ecx
+	0x48, 0xc1, 0xe1, 0x10, //0x000003d0 shlq         $16, %rcx
+	0x48, 0x09, 0xf9, //0x000003d4 orq          %rdi, %rcx
+	0xc5, 0xe9, 0x74, 0xd1, //0x000003d7 vpcmpeqb     %xmm1, %xmm2, %xmm2
+	0xc5, 0xf9, 0xd7, 0xda, //0x000003db vpmovmskb    %xmm2, %ebx
+	0xc5, 0xe1, 0x74, 0xd1, //0x000003df vpcmpeqb     %xmm1, %xmm3, %xmm2
+	0xc5, 0xf9, 0xd7, 0xfa, //0x000003e3 vpmovmskb    %xmm2, %edi
+	0x48, 0xc1, 0xe7, 0x10, //0x000003e7 shlq         $16, %rdi
+	0x48, 0x09, 0xdf, //0x000003eb orq          %rbx, %rdi
+	0x48, 0x89, 0xfb, //0x000003ee movq         %rdi, %rbx
+	0x4c, 0x09, 0xe3, //0x000003f1 orq          %r12, %rbx
+	0x0f, 0x84, 0x96, 0xff, 0xff, 0xff, //0x000003f4 je           LBB0_52
+	0x44, 0x89, 0xe3, //0x000003fa movl         %r12d, %ebx
+	0x44, 0x31, 0xcb, //0x000003fd xorl         %r9d, %ebx
+	0x21, 0xdf, //0x00000400 andl         %ebx, %edi
+	0x8d, 0x1c, 0x3f, //0x00000402 leal         (%rdi,%rdi), %ebx
+	0x44, 0x09, 0xe3, //0x00000405 orl          %r12d, %ebx
+	0x41, 0x8d, 0x91, 0xab, 0xaa, 0xaa, 0xaa, //0x00000408 leal         $-1431655765(%r9), %edx
+	0x31, 0xda, //0x0000040f xorl         %ebx, %edx
+	0x21, 0xfa, //0x00000411 andl         %edi, %edx
+	0x81, 0xe2, 0xaa, 0xaa, 0xaa, 0xaa, //0x00000413 andl         $-1431655766, %edx
+	0x45, 0x31, 0xe4, //0x00000419 xorl         %r12d, %r12d
+	0x01, 0xfa, //0x0000041c addl         %edi, %edx
+	0x41, 0x0f, 0x92, 0xc4, //0x0000041e setb         %r12b
+	0x01, 0xd2, //0x00000422 addl         %edx, %edx
+	0x81, 0xf2, 0x55, 0x55, 0x55, 0x55, //0x00000424 xorl         $1431655765, %edx
+	0x21, 0xda, //0x0000042a andl         %ebx, %edx
+	0x44, 0x31, 0xca, //0x0000042c xorl         %r9d, %edx
+	0x21, 0xd1, //0x0000042f andl         %edx, %ecx
+	0x85, 0xc9, //0x00000431 testl        %ecx, %ecx
+	0x0f, 0x84, 0x62, 0xff, 0xff, 0xff, //0x00000433 je           LBB0_53
+	//0x00000439 LBB0_110
+	0x48, 0x0f, 0xbc, 0xc1, //0x00000439 bsfq         %rcx, %rax
+	0x49, 0x01, 0xc2, //0x0000043d addq         %rax, %r10
+	0x4d, 0x01, 0xfa, //0x00000440 addq         %r15, %r10
+	0x4d, 0x29, 0xf2, //0x00000443 subq         %r14, %r10
+	0x49, 0x83, 0xc2, 0x02, //0x00000446 addq         $2, %r10
+	0x4c, 0x89, 0x16, //0x0000044a movq         %r10, (%rsi)
+	0xe9, 0xb9, 0xfe, 0xff, 0xff, //0x0000044d jmp          LBB0_44
+	//0x00000452 LBB0_57
+	0x48, 0x8b, 0x4f, 0x08, //0x00000452 movq         $8(%rdi), %rcx
+	0x48, 0x29, 0xd9, //0x00000456 subq         %rbx, %rcx
+	0x49, 0x01, 0xde, //0x00000459 addq         %rbx, %r14
+	0x45, 0x31, 0xe4, //0x0000045c xorl         %r12d, %r12d
+	0xc5, 0x7a, 0x6f, 0x15, 0xc9, 0xfb, 0xff, 0xff, //0x0000045f vmovdqu      $-1079(%rip), %xmm10  /* LCPI0_3+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x0d, 0xd1, 0xfb, 0xff, 0xff, //0x00000467 vmovdqu      $-1071(%rip), %xmm1  /* LCPI0_4+0(%rip) */
+	0xc4, 0x41, 0x31, 0x76, 0xc9, //0x0000046f vpcmpeqd     %xmm9, %xmm9, %xmm9
+	0xc5, 0xfa, 0x6f, 0x1d, 0xe4, 0xfb, 0xff, 0xff, //0x00000474 vmovdqu      $-1052(%rip), %xmm3  /* LCPI0_6+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x25, 0xec, 0xfb, 0xff, 0xff, //0x0000047c vmovdqu      $-1044(%rip), %xmm4  /* LCPI0_7+0(%rip) */
+	0xc4, 0x41, 0x38, 0x57, 0xc0, //0x00000484 vxorps       %xmm8, %xmm8, %xmm8
+	0x31, 0xdb, //0x00000489 xorl         %ebx, %ebx
+	0x45, 0x31, 0xc0, //0x0000048b xorl         %r8d, %r8d
+	0x45, 0x31, 0xff, //0x0000048e xorl         %r15d, %r15d
+	0x48, 0x83, 0xf9, 0x40, //0x00000491 cmpq         $64, %rcx
+	0x48, 0x89, 0x4c, 0x24, 0x08, //0x00000495 movq         %rcx, $8(%rsp)
+	0x4c, 0x89, 0x44, 0x24, 0x10, //0x0000049a movq         %r8, $16(%rsp)
+	0x0f, 0x8d, 0x33, 0x01, 0x00, 0x00, //0x0000049f jge          LBB0_58
+	//0x000004a5 LBB0_67
+	0x48, 0x85, 0xc9, //0x000004a5 testq        %rcx, %rcx
+	0x0f, 0x8e, 0x6b, 0x07, 0x00, 0x00, //0x000004a8 jle          LBB0_118
+	0xc5, 0x7c, 0x11, 0x44, 0x24, 0x40, //0x000004ae vmovups      %ymm8, $64(%rsp)
+	0xc5, 0x7c, 0x11, 0x44, 0x24, 0x20, //0x000004b4 vmovups      %ymm8, $32(%rsp)
+	0x44, 0x89, 0xf1, //0x000004ba movl         %r14d, %ecx
+	0x81, 0xe1, 0xff, 0x0f, 0x00, 0x00, //0x000004bd andl         $4095, %ecx
+	0x81, 0xf9, 0xc1, 0x0f, 0x00, 0x00, //0x000004c3 cmpl         $4033, %ecx
+	0x0f, 0x82, 0x09, 0x01, 0x00, 0x00, //0x000004c9 jb           LBB0_58
+	0x48, 0x83, 0x7c, 0x24, 0x08, 0x20, //0x000004cf cmpq         $32, $8(%rsp)
+	0x0f, 0x82, 0x2e, 0x00, 0x00, 0x00, //0x000004d5 jb           LBB0_71
+	0xc4, 0xc1, 0x78, 0x10, 0x06, //0x000004db vmovups      (%r14), %xmm0
+	0xc5, 0xf8, 0x11, 0x44, 0x24, 0x20, //0x000004e0 vmovups      %xmm0, $32(%rsp)
+	0xc4, 0xc1, 0x7a, 0x6f, 0x46, 0x10, //0x000004e6 vmovdqu      $16(%r14), %xmm0
+	0xc5, 0xfa, 0x7f, 0x44, 0x24, 0x30, //0x000004ec vmovdqu      %xmm0, $48(%rsp)
+	0x49, 0x83, 0xc6, 0x20, //0x000004f2 addq         $32, %r14
+	0x48, 0x8b, 0x4c, 0x24, 0x08, //0x000004f6 movq         $8(%rsp), %rcx
+	0x48, 0x8d, 0x51, 0xe0, //0x000004fb leaq         $-32(%rcx), %rdx
+	0x4c, 0x8d, 0x44, 0x24, 0x40, //0x000004ff leaq         $64(%rsp), %r8
+	0xe9, 0x0a, 0x00, 0x00, 0x00, //0x00000504 jmp          LBB0_72
+	//0x00000509 LBB0_71
+	0x4c, 0x8d, 0x44, 0x24, 0x20, //0x00000509 leaq         $32(%rsp), %r8
+	0x48, 0x8b, 0x54, 0x24, 0x08, //0x0000050e movq         $8(%rsp), %rdx
+	//0x00000513 LBB0_72
+	0x48, 0x83, 0xfa, 0x10, //0x00000513 cmpq         $16, %rdx
+	0x0f, 0x82, 0x5c, 0x00, 0x00, 0x00, //0x00000517 jb           LBB0_73
+	0xc4, 0xc1, 0x7a, 0x6f, 0x06, //0x0000051d vmovdqu      (%r14), %xmm0
+	0xc4, 0xc1, 0x7a, 0x7f, 0x00, //0x00000522 vmovdqu      %xmm0, (%r8)
+	0x49, 0x83, 0xc6, 0x10, //0x00000527 addq         $16, %r14
+	0x49, 0x83, 0xc0, 0x10, //0x0000052b addq         $16, %r8
+	0x48, 0x83, 0xc2, 0xf0, //0x0000052f addq         $-16, %rdx
+	0x48, 0x83, 0xfa, 0x08, //0x00000533 cmpq         $8, %rdx
+	0x0f, 0x83, 0x46, 0x00, 0x00, 0x00, //0x00000537 jae          LBB0_78
+	//0x0000053d LBB0_74
+	0x48, 0x83, 0xfa, 0x04, //0x0000053d cmpq         $4, %rdx
+	0x0f, 0x8c, 0x58, 0x00, 0x00, 0x00, //0x00000541 jl           LBB0_75
+	//0x00000547 LBB0_79
+	0x41, 0x8b, 0x0e, //0x00000547 movl         (%r14), %ecx
+	0x41, 0x89, 0x08, //0x0000054a movl         %ecx, (%r8)
+	0x49, 0x83, 0xc6, 0x04, //0x0000054d addq         $4, %r14
+	0x49, 0x83, 0xc0, 0x04, //0x00000551 addq         $4, %r8
+	0x48, 0x83, 0xc2, 0xfc, //0x00000555 addq         $-4, %rdx
+	0x48, 0x83, 0xfa, 0x02, //0x00000559 cmpq         $2, %rdx
+	0x0f, 0x83, 0x46, 0x00, 0x00, 0x00, //0x0000055d jae          LBB0_80
+	//0x00000563 LBB0_76
+	0x4c, 0x89, 0xf1, //0x00000563 movq         %r14, %rcx
+	0x4c, 0x8d, 0x74, 0x24, 0x20, //0x00000566 leaq         $32(%rsp), %r14
+	0x48, 0x85, 0xd2, //0x0000056b testq        %rdx, %rdx
+	0x0f, 0x85, 0x5a, 0x00, 0x00, 0x00, //0x0000056e jne          LBB0_81
+	0xe9, 0x5f, 0x00, 0x00, 0x00, //0x00000574 jmp          LBB0_58
+	//0x00000579 LBB0_73
+	0x48, 0x83, 0xfa, 0x08, //0x00000579 cmpq         $8, %rdx
+	0x0f, 0x82, 0xba, 0xff, 0xff, 0xff, //0x0000057d jb           LBB0_74
+	//0x00000583 LBB0_78
+	0x49, 0x8b, 0x0e, //0x00000583 movq         (%r14), %rcx
+	0x49, 0x89, 0x08, //0x00000586 movq         %rcx, (%r8)
+	0x49, 0x83, 0xc6, 0x08, //0x00000589 addq         $8, %r14
+	0x49, 0x83, 0xc0, 0x08, //0x0000058d addq         $8, %r8
+	0x48, 0x83, 0xc2, 0xf8, //0x00000591 addq         $-8, %rdx
+	0x48, 0x83, 0xfa, 0x04, //0x00000595 cmpq         $4, %rdx
+	0x0f, 0x8d, 0xa8, 0xff, 0xff, 0xff, //0x00000599 jge          LBB0_79
+	//0x0000059f LBB0_75
+	0x48, 0x83, 0xfa, 0x02, //0x0000059f cmpq         $2, %rdx
+	0x0f, 0x82, 0xba, 0xff, 0xff, 0xff, //0x000005a3 jb           LBB0_76
+	//0x000005a9 LBB0_80
+	0x41, 0x0f, 0xb7, 0x0e, //0x000005a9 movzwl       (%r14), %ecx
+	0x66, 0x41, 0x89, 0x08, //0x000005ad movw         %cx, (%r8)
+	0x49, 0x83, 0xc6, 0x02, //0x000005b1 addq         $2, %r14
+	0x49, 0x83, 0xc0, 0x02, //0x000005b5 addq         $2, %r8
+	0x48, 0x83, 0xc2, 0xfe, //0x000005b9 addq         $-2, %rdx
+	0x4c, 0x89, 0xf1, //0x000005bd movq         %r14, %rcx
+	0x4c, 0x8d, 0x74, 0x24, 0x20, //0x000005c0 leaq         $32(%rsp), %r14
+	0x48, 0x85, 0xd2, //0x000005c5 testq        %rdx, %rdx
+	0x0f, 0x84, 0x0a, 0x00, 0x00, 0x00, //0x000005c8 je           LBB0_58
+	//0x000005ce LBB0_81
+	0x8a, 0x09, //0x000005ce movb         (%rcx), %cl
+	0x41, 0x88, 0x08, //0x000005d0 movb         %cl, (%r8)
+	0x4c, 0x8d, 0x74, 0x24, 0x20, //0x000005d3 leaq         $32(%rsp), %r14
+	//0x000005d8 LBB0_58
+	0xc4, 0xc1, 0x7a, 0x6f, 0x16, //0x000005d8 vmovdqu      (%r14), %xmm2
+	0xc4, 0xc1, 0x7a, 0x6f, 0x6e, 0x10, //0x000005dd vmovdqu      $16(%r14), %xmm5
+	0xc4, 0xc1, 0x7a, 0x6f, 0x7e, 0x20, //0x000005e3 vmovdqu      $32(%r14), %xmm7
+	0xc4, 0xc1, 0x7a, 0x6f, 0x76, 0x30, //0x000005e9 vmovdqu      $48(%r14), %xmm6
+	0xc5, 0xa9, 0x74, 0xc2, //0x000005ef vpcmpeqb     %xmm2, %xmm10, %xmm0
+	0xc5, 0x79, 0xd7, 0xe8, //0x000005f3 vpmovmskb    %xmm0, %r13d
+	0xc5, 0xa9, 0x74, 0xc5, //0x000005f7 vpcmpeqb     %xmm5, %xmm10, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc8, //0x000005fb vpmovmskb    %xmm0, %ecx
+	0xc5, 0xa9, 0x74, 0xc7, //0x000005ff vpcmpeqb     %xmm7, %xmm10, %xmm0
+	0xc5, 0xf9, 0xd7, 0xd0, //0x00000603 vpmovmskb    %xmm0, %edx
+	0xc5, 0xa9, 0x74, 0xc6, //0x00000607 vpcmpeqb     %xmm6, %xmm10, %xmm0
+	0xc5, 0x79, 0xd7, 0xc8, //0x0000060b vpmovmskb    %xmm0, %r9d
+	0x49, 0xc1, 0xe1, 0x30, //0x0000060f shlq         $48, %r9
+	0x48, 0xc1, 0xe2, 0x20, //0x00000613 shlq         $32, %rdx
+	0x48, 0xc1, 0xe1, 0x10, //0x00000617 shlq         $16, %rcx
+	0x49, 0x09, 0xcd, //0x0000061b orq          %rcx, %r13
+	0x49, 0x09, 0xd5, //0x0000061e orq          %rdx, %r13
+	0x4d, 0x09, 0xcd, //0x00000621 orq          %r9, %r13
+	0xc5, 0xe9, 0x74, 0xc1, //0x00000624 vpcmpeqb     %xmm1, %xmm2, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc8, //0x00000628 vpmovmskb    %xmm0, %ecx
+	0xc5, 0xd1, 0x74, 0xc1, //0x0000062c vpcmpeqb     %xmm1, %xmm5, %xmm0
+	0xc5, 0xf9, 0xd7, 0xd0, //0x00000630 vpmovmskb    %xmm0, %edx
+	0xc5, 0xc1, 0x74, 0xc1, //0x00000634 vpcmpeqb     %xmm1, %xmm7, %xmm0
+	0xc5, 0x79, 0xd7, 0xc8, //0x00000638 vpmovmskb    %xmm0, %r9d
+	0xc5, 0xc9, 0x74, 0xc1, //0x0000063c vpcmpeqb     %xmm1, %xmm6, %xmm0
+	0xc5, 0x79, 0xd7, 0xd0, //0x00000640 vpmovmskb    %xmm0, %r10d
+	0x49, 0xc1, 0xe2, 0x30, //0x00000644 shlq         $48, %r10
+	0x49, 0xc1, 0xe1, 0x20, //0x00000648 shlq         $32, %r9
+	0x48, 0xc1, 0xe2, 0x10, //0x0000064c shlq         $16, %rdx
+	0x48, 0x09, 0xd1, //0x00000650 orq          %rdx, %rcx
+	0x4c, 0x09, 0xc9, //0x00000653 orq          %r9, %rcx
+	0x4c, 0x09, 0xd1, //0x00000656 orq          %r10, %rcx
+	0x48, 0x89, 0xca, //0x00000659 movq         %rcx, %rdx
+	0x48, 0x09, 0xda, //0x0000065c orq          %rbx, %rdx
+	0x0f, 0x84, 0x49, 0x00, 0x00, 0x00, //0x0000065f je           LBB0_60
+	0x48, 0x89, 0xda, //0x00000665 movq         %rbx, %rdx
+	0x48, 0xf7, 0xd2, //0x00000668 notq         %rdx
+	0x48, 0x21, 0xca, //0x0000066b andq         %rcx, %rdx
+	0x4c, 0x8d, 0x0c, 0x12, //0x0000066e leaq         (%rdx,%rdx), %r9
+	0x49, 0x09, 0xd9, //0x00000672 orq          %rbx, %r9
+	0x4d, 0x89, 0xca, //0x00000675 movq         %r9, %r10
+	0x48, 0xbb, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, //0x00000678 movabsq      $-6148914691236517206, %rbx
+	0x49, 0x31, 0xda, //0x00000682 xorq         %rbx, %r10
+	0x48, 0x21, 0xd9, //0x00000685 andq         %rbx, %rcx
+	0x4c, 0x21, 0xd1, //0x00000688 andq         %r10, %rcx
+	0x31, 0xdb, //0x0000068b xorl         %ebx, %ebx
+	0x48, 0x01, 0xd1, //0x0000068d addq         %rdx, %rcx
+	0x0f, 0x92, 0xc3, //0x00000690 setb         %bl
+	0x48, 0x01, 0xc9, //0x00000693 addq         %rcx, %rcx
+	0x48, 0xba, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, //0x00000696 movabsq      $6148914691236517205, %rdx
+	0x48, 0x31, 0xd1, //0x000006a0 xorq         %rdx, %rcx
+	0x4c, 0x21, 0xc9, //0x000006a3 andq         %r9, %rcx
+	0x48, 0xf7, 0xd1, //0x000006a6 notq         %rcx
+	0xe9, 0x09, 0x00, 0x00, 0x00, //0x000006a9 jmp          LBB0_61
+	//0x000006ae LBB0_60
+	0x48, 0xc7, 0xc1, 0xff, 0xff, 0xff, 0xff, //0x000006ae movq         $-1, %rcx
+	0x31, 0xdb, //0x000006b5 xorl         %ebx, %ebx
+	//0x000006b7 LBB0_61
+	0x48, 0x89, 0x5c, 0x24, 0x18, //0x000006b7 movq         %rbx, $24(%rsp)
+	0x4c, 0x21, 0xe9, //0x000006bc andq         %r13, %rcx
+	0xc4, 0xe1, 0xf9, 0x6e, 0xc1, //0x000006bf vmovq        %rcx, %xmm0
+	0xc4, 0xc3, 0x79, 0x44, 0xc1, 0x00, //0x000006c4 vpclmulqdq   $0, %xmm9, %xmm0, %xmm0
+	0xc4, 0xc1, 0xf9, 0x7e, 0xc5, //0x000006ca vmovq        %xmm0, %r13
+	0x4d, 0x31, 0xe5, //0x000006cf xorq         %r12, %r13
+	0xc5, 0xe9, 0x74, 0xc3, //0x000006d2 vpcmpeqb     %xmm3, %xmm2, %xmm0
+	0xc5, 0x79, 0xd7, 0xd0, //0x000006d6 vpmovmskb    %xmm0, %r10d
+	0xc5, 0xd1, 0x74, 0xc3, //0x000006da vpcmpeqb     %xmm3, %xmm5, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc8, //0x000006de vpmovmskb    %xmm0, %ecx
+	0xc5, 0xc1, 0x74, 0xc3, //0x000006e2 vpcmpeqb     %xmm3, %xmm7, %xmm0
+	0xc5, 0xf9, 0xd7, 0xd0, //0x000006e6 vpmovmskb    %xmm0, %edx
+	0xc5, 0xc9, 0x74, 0xc3, //0x000006ea vpcmpeqb     %xmm3, %xmm6, %xmm0
+	0xc5, 0x79, 0xd7, 0xc8, //0x000006ee vpmovmskb    %xmm0, %r9d
+	0x49, 0xc1, 0xe1, 0x30, //0x000006f2 shlq         $48, %r9
+	0x48, 0xc1, 0xe2, 0x20, //0x000006f6 shlq         $32, %rdx
+	0x48, 0xc1, 0xe1, 0x10, //0x000006fa shlq         $16, %rcx
+	0x49, 0x09, 0xca, //0x000006fe orq          %rcx, %r10
+	0x49, 0x09, 0xd2, //0x00000701 orq          %rdx, %r10
+	0x4d, 0x09, 0xca, //0x00000704 orq          %r9, %r10
+	0x4d, 0x89, 0xe9, //0x00000707 movq         %r13, %r9
+	0x49, 0xf7, 0xd1, //0x0000070a notq         %r9
+	0x4d, 0x21, 0xca, //0x0000070d andq         %r9, %r10
+	0xc5, 0xe9, 0x74, 0xc4, //0x00000710 vpcmpeqb     %xmm4, %xmm2, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc8, //0x00000714 vpmovmskb    %xmm0, %ecx
+	0xc5, 0xd1, 0x74, 0xc4, //0x00000718 vpcmpeqb     %xmm4, %xmm5, %xmm0
+	0xc5, 0xf9, 0xd7, 0xd0, //0x0000071c vpmovmskb    %xmm0, %edx
+	0xc5, 0xc1, 0x74, 0xc4, //0x00000720 vpcmpeqb     %xmm4, %xmm7, %xmm0
+	0xc5, 0x79, 0xd7, 0xc0, //0x00000724 vpmovmskb    %xmm0, %r8d
+	0xc5, 0xc9, 0x74, 0xc4, //0x00000728 vpcmpeqb     %xmm4, %xmm6, %xmm0
+	0xc5, 0x79, 0xd7, 0xe0, //0x0000072c vpmovmskb    %xmm0, %r12d
+	0x49, 0xc1, 0xe4, 0x30, //0x00000730 shlq         $48, %r12
+	0x49, 0xc1, 0xe0, 0x20, //0x00000734 shlq         $32, %r8
+	0x48, 0xc1, 0xe2, 0x10, //0x00000738 shlq         $16, %rdx
+	0x48, 0x09, 0xd1, //0x0000073c orq          %rdx, %rcx
+	0x4c, 0x09, 0xc1, //0x0000073f orq          %r8, %rcx
+	0x4c, 0x09, 0xe1, //0x00000742 orq          %r12, %rcx
+	0x4c, 0x21, 0xc9, //0x00000745 andq         %r9, %rcx
+	0x0f, 0x84, 0x3e, 0x00, 0x00, 0x00, //0x00000748 je           LBB0_65
+	0x4c, 0x8b, 0x44, 0x24, 0x10, //0x0000074e movq         $16(%rsp), %r8
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000753 .p2align 4, 0x90
+	//0x00000760 LBB0_63
+	0x48, 0x8d, 0x59, 0xff, //0x00000760 leaq         $-1(%rcx), %rbx
+	0x48, 0x89, 0xda, //0x00000764 movq         %rbx, %rdx
+	0x4c, 0x21, 0xd2, //0x00000767 andq         %r10, %rdx
+	0xf3, 0x48, 0x0f, 0xb8, 0xd2, //0x0000076a popcntq      %rdx, %rdx
+	0x4c, 0x01, 0xc2, //0x0000076f addq         %r8, %rdx
+	0x4c, 0x39, 0xfa, //0x00000772 cmpq         %r15, %rdx
+	0x0f, 0x86, 0xe0, 0x03, 0x00, 0x00, //0x00000775 jbe          LBB0_109
+	0x49, 0xff, 0xc7, //0x0000077b incq         %r15
+	0x48, 0x21, 0xd9, //0x0000077e andq         %rbx, %rcx
+	0x0f, 0x85, 0xd9, 0xff, 0xff, 0xff, //0x00000781 jne          LBB0_63
+	0xe9, 0x05, 0x00, 0x00, 0x00, //0x00000787 jmp          LBB0_66
+	//0x0000078c LBB0_65
+	0x4c, 0x8b, 0x44, 0x24, 0x10, //0x0000078c movq         $16(%rsp), %r8
+	//0x00000791 LBB0_66
+	0x49, 0xc1, 0xfd, 0x3f, //0x00000791 sarq         $63, %r13
+	0xf3, 0x49, 0x0f, 0xb8, 0xca, //0x00000795 popcntq      %r10, %rcx
+	0x49, 0x01, 0xc8, //0x0000079a addq         %rcx, %r8
+	0x49, 0x83, 0xc6, 0x40, //0x0000079d addq         $64, %r14
+	0x48, 0x8b, 0x4c, 0x24, 0x08, //0x000007a1 movq         $8(%rsp), %rcx
+	0x48, 0x83, 0xc1, 0xc0, //0x000007a6 addq         $-64, %rcx
+	0x4d, 0x89, 0xec, //0x000007aa movq         %r13, %r12
+	0x48, 0x8b, 0x5c, 0x24, 0x18, //0x000007ad movq         $24(%rsp), %rbx
+	0x48, 0x83, 0xf9, 0x40, //0x000007b2 cmpq         $64, %rcx
+	0x48, 0x89, 0x4c, 0x24, 0x08, //0x000007b6 movq         %rcx, $8(%rsp)
+	0x4c, 0x89, 0x44, 0x24, 0x10, //0x000007bb movq         %r8, $16(%rsp)
+	0x0f, 0x8d, 0x12, 0xfe, 0xff, 0xff, //0x000007c0 jge          LBB0_58
+	0xe9, 0xda, 0xfc, 0xff, 0xff, //0x000007c6 jmp          LBB0_67
+	//0x000007cb LBB0_82
+	0x49, 0x8d, 0x4b, 0x05, //0x000007cb leaq         $5(%r11), %rcx
+	0x48, 0x3b, 0x4f, 0x08, //0x000007cf cmpq         $8(%rdi), %rcx
+	0x0f, 0x87, 0x35, 0xfb, 0xff, 0xff, //0x000007d3 ja           LBB0_45
+	//0x000007d9 LBB0_83
+	0x48, 0x89, 0x0e, //0x000007d9 movq         %rcx, (%rsi)
+	0xe9, 0x2a, 0xfb, 0xff, 0xff, //0x000007dc jmp          LBB0_44
+	//0x000007e1 LBB0_84
+	0x48, 0x8b, 0x4f, 0x08, //0x000007e1 movq         $8(%rdi), %rcx
+	0x48, 0x29, 0xd9, //0x000007e5 subq         %rbx, %rcx
+	0x49, 0x01, 0xde, //0x000007e8 addq         %rbx, %r14
+	0x45, 0x31, 0xe4, //0x000007eb xorl         %r12d, %r12d
+	0xc5, 0x7a, 0x6f, 0x15, 0x3a, 0xf8, 0xff, 0xff, //0x000007ee vmovdqu      $-1990(%rip), %xmm10  /* LCPI0_3+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x0d, 0x42, 0xf8, 0xff, 0xff, //0x000007f6 vmovdqu      $-1982(%rip), %xmm1  /* LCPI0_4+0(%rip) */
+	0xc4, 0x41, 0x31, 0x76, 0xc9, //0x000007fe vpcmpeqd     %xmm9, %xmm9, %xmm9
+	0xc5, 0xfa, 0x6f, 0x1d, 0x45, 0xf8, 0xff, 0xff, //0x00000803 vmovdqu      $-1979(%rip), %xmm3  /* LCPI0_5+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x25, 0x0d, 0xf8, 0xff, 0xff, //0x0000080b vmovdqu      $-2035(%rip), %xmm4  /* LCPI0_2+0(%rip) */
+	0xc4, 0x41, 0x38, 0x57, 0xc0, //0x00000813 vxorps       %xmm8, %xmm8, %xmm8
+	0x31, 0xdb, //0x00000818 xorl         %ebx, %ebx
+	0x45, 0x31, 0xc0, //0x0000081a xorl         %r8d, %r8d
+	0x45, 0x31, 0xff, //0x0000081d xorl         %r15d, %r15d
+	0x48, 0x83, 0xf9, 0x40, //0x00000820 cmpq         $64, %rcx
+	0x48, 0x89, 0x4c, 0x24, 0x08, //0x00000824 movq         %rcx, $8(%rsp)
+	0x4c, 0x89, 0x44, 0x24, 0x10, //0x00000829 movq         %r8, $16(%rsp)
+	0x0f, 0x8d, 0x33, 0x01, 0x00, 0x00, //0x0000082e jge          LBB0_85
+	//0x00000834 LBB0_94
+	0x48, 0x85, 0xc9, //0x00000834 testq        %rcx, %rcx
+	0x0f, 0x8e, 0xdc, 0x03, 0x00, 0x00, //0x00000837 jle          LBB0_118
+	0xc5, 0x7c, 0x11, 0x44, 0x24, 0x40, //0x0000083d vmovups      %ymm8, $64(%rsp)
+	0xc5, 0x7c, 0x11, 0x44, 0x24, 0x20, //0x00000843 vmovups      %ymm8, $32(%rsp)
+	0x44, 0x89, 0xf1, //0x00000849 movl         %r14d, %ecx
+	0x81, 0xe1, 0xff, 0x0f, 0x00, 0x00, //0x0000084c andl         $4095, %ecx
+	0x81, 0xf9, 0xc1, 0x0f, 0x00, 0x00, //0x00000852 cmpl         $4033, %ecx
+	0x0f, 0x82, 0x09, 0x01, 0x00, 0x00, //0x00000858 jb           LBB0_85
+	0x48, 0x83, 0x7c, 0x24, 0x08, 0x20, //0x0000085e cmpq         $32, $8(%rsp)
+	0x0f, 0x82, 0x2e, 0x00, 0x00, 0x00, //0x00000864 jb           LBB0_98
+	0xc4, 0xc1, 0x78, 0x10, 0x06, //0x0000086a vmovups      (%r14), %xmm0
+	0xc5, 0xf8, 0x11, 0x44, 0x24, 0x20, //0x0000086f vmovups      %xmm0, $32(%rsp)
+	0xc4, 0xc1, 0x7a, 0x6f, 0x46, 0x10, //0x00000875 vmovdqu      $16(%r14), %xmm0
+	0xc5, 0xfa, 0x7f, 0x44, 0x24, 0x30, //0x0000087b vmovdqu      %xmm0, $48(%rsp)
+	0x49, 0x83, 0xc6, 0x20, //0x00000881 addq         $32, %r14
+	0x48, 0x8b, 0x4c, 0x24, 0x08, //0x00000885 movq         $8(%rsp), %rcx
+	0x48, 0x8d, 0x51, 0xe0, //0x0000088a leaq         $-32(%rcx), %rdx
+	0x4c, 0x8d, 0x44, 0x24, 0x40, //0x0000088e leaq         $64(%rsp), %r8
+	0xe9, 0x0a, 0x00, 0x00, 0x00, //0x00000893 jmp          LBB0_99
+	//0x00000898 LBB0_98
+	0x4c, 0x8d, 0x44, 0x24, 0x20, //0x00000898 leaq         $32(%rsp), %r8
+	0x48, 0x8b, 0x54, 0x24, 0x08, //0x0000089d movq         $8(%rsp), %rdx
+	//0x000008a2 LBB0_99
+	0x48, 0x83, 0xfa, 0x10, //0x000008a2 cmpq         $16, %rdx
+	0x0f, 0x82, 0x5c, 0x00, 0x00, 0x00, //0x000008a6 jb           LBB0_100
+	0xc4, 0xc1, 0x7a, 0x6f, 0x06, //0x000008ac vmovdqu      (%r14), %xmm0
+	0xc4, 0xc1, 0x7a, 0x7f, 0x00, //0x000008b1 vmovdqu      %xmm0, (%r8)
+	0x49, 0x83, 0xc6, 0x10, //0x000008b6 addq         $16, %r14
+	0x49, 0x83, 0xc0, 0x10, //0x000008ba addq         $16, %r8
+	0x48, 0x83, 0xc2, 0xf0, //0x000008be addq         $-16, %rdx
+	0x48, 0x83, 0xfa, 0x08, //0x000008c2 cmpq         $8, %rdx
+	0x0f, 0x83, 0x46, 0x00, 0x00, 0x00, //0x000008c6 jae          LBB0_105
+	//0x000008cc LBB0_101
+	0x48, 0x83, 0xfa, 0x04, //0x000008cc cmpq         $4, %rdx
+	0x0f, 0x8c, 0x58, 0x00, 0x00, 0x00, //0x000008d0 jl           LBB0_102
+	//0x000008d6 LBB0_106
+	0x41, 0x8b, 0x0e, //0x000008d6 movl         (%r14), %ecx
+	0x41, 0x89, 0x08, //0x000008d9 movl         %ecx, (%r8)
+	0x49, 0x83, 0xc6, 0x04, //0x000008dc addq         $4, %r14
+	0x49, 0x83, 0xc0, 0x04, //0x000008e0 addq         $4, %r8
+	0x48, 0x83, 0xc2, 0xfc, //0x000008e4 addq         $-4, %rdx
+	0x48, 0x83, 0xfa, 0x02, //0x000008e8 cmpq         $2, %rdx
+	0x0f, 0x83, 0x46, 0x00, 0x00, 0x00, //0x000008ec jae          LBB0_107
+	//0x000008f2 LBB0_103
+	0x4c, 0x89, 0xf1, //0x000008f2 movq         %r14, %rcx
+	0x4c, 0x8d, 0x74, 0x24, 0x20, //0x000008f5 leaq         $32(%rsp), %r14
+	0x48, 0x85, 0xd2, //0x000008fa testq        %rdx, %rdx
+	0x0f, 0x85, 0x5a, 0x00, 0x00, 0x00, //0x000008fd jne          LBB0_108
+	0xe9, 0x5f, 0x00, 0x00, 0x00, //0x00000903 jmp          LBB0_85
+	//0x00000908 LBB0_100
+	0x48, 0x83, 0xfa, 0x08, //0x00000908 cmpq         $8, %rdx
+	0x0f, 0x82, 0xba, 0xff, 0xff, 0xff, //0x0000090c jb           LBB0_101
+	//0x00000912 LBB0_105
+	0x49, 0x8b, 0x0e, //0x00000912 movq         (%r14), %rcx
+	0x49, 0x89, 0x08, //0x00000915 movq         %rcx, (%r8)
+	0x49, 0x83, 0xc6, 0x08, //0x00000918 addq         $8, %r14
+	0x49, 0x83, 0xc0, 0x08, //0x0000091c addq         $8, %r8
+	0x48, 0x83, 0xc2, 0xf8, //0x00000920 addq         $-8, %rdx
+	0x48, 0x83, 0xfa, 0x04, //0x00000924 cmpq         $4, %rdx
+	0x0f, 0x8d, 0xa8, 0xff, 0xff, 0xff, //0x00000928 jge          LBB0_106
+	//0x0000092e LBB0_102
+	0x48, 0x83, 0xfa, 0x02, //0x0000092e cmpq         $2, %rdx
+	0x0f, 0x82, 0xba, 0xff, 0xff, 0xff, //0x00000932 jb           LBB0_103
+	//0x00000938 LBB0_107
+	0x41, 0x0f, 0xb7, 0x0e, //0x00000938 movzwl       (%r14), %ecx
+	0x66, 0x41, 0x89, 0x08, //0x0000093c movw         %cx, (%r8)
+	0x49, 0x83, 0xc6, 0x02, //0x00000940 addq         $2, %r14
+	0x49, 0x83, 0xc0, 0x02, //0x00000944 addq         $2, %r8
+	0x48, 0x83, 0xc2, 0xfe, //0x00000948 addq         $-2, %rdx
+	0x4c, 0x89, 0xf1, //0x0000094c movq         %r14, %rcx
+	0x4c, 0x8d, 0x74, 0x24, 0x20, //0x0000094f leaq         $32(%rsp), %r14
+	0x48, 0x85, 0xd2, //0x00000954 testq        %rdx, %rdx
+	0x0f, 0x84, 0x0a, 0x00, 0x00, 0x00, //0x00000957 je           LBB0_85
+	//0x0000095d LBB0_108
+	0x8a, 0x09, //0x0000095d movb         (%rcx), %cl
+	0x41, 0x88, 0x08, //0x0000095f movb         %cl, (%r8)
+	0x4c, 0x8d, 0x74, 0x24, 0x20, //0x00000962 leaq         $32(%rsp), %r14
+	//0x00000967 LBB0_85
+	0xc4, 0xc1, 0x7a, 0x6f, 0x16, //0x00000967 vmovdqu      (%r14), %xmm2
+	0xc4, 0xc1, 0x7a, 0x6f, 0x6e, 0x10, //0x0000096c vmovdqu      $16(%r14), %xmm5
+	0xc4, 0xc1, 0x7a, 0x6f, 0x7e, 0x20, //0x00000972 vmovdqu      $32(%r14), %xmm7
+	0xc4, 0xc1, 0x7a, 0x6f, 0x76, 0x30, //0x00000978 vmovdqu      $48(%r14), %xmm6
+	0xc5, 0xa9, 0x74, 0xc2, //0x0000097e vpcmpeqb     %xmm2, %xmm10, %xmm0
+	0xc5, 0x79, 0xd7, 0xe8, //0x00000982 vpmovmskb    %xmm0, %r13d
+	0xc5, 0xa9, 0x74, 0xc5, //0x00000986 vpcmpeqb     %xmm5, %xmm10, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc8, //0x0000098a vpmovmskb    %xmm0, %ecx
+	0xc5, 0xa9, 0x74, 0xc7, //0x0000098e vpcmpeqb     %xmm7, %xmm10, %xmm0
+	0xc5, 0xf9, 0xd7, 0xd0, //0x00000992 vpmovmskb    %xmm0, %edx
+	0xc5, 0xa9, 0x74, 0xc6, //0x00000996 vpcmpeqb     %xmm6, %xmm10, %xmm0
+	0xc5, 0x79, 0xd7, 0xc8, //0x0000099a vpmovmskb    %xmm0, %r9d
+	0x49, 0xc1, 0xe1, 0x30, //0x0000099e shlq         $48, %r9
+	0x48, 0xc1, 0xe2, 0x20, //0x000009a2 shlq         $32, %rdx
+	0x48, 0xc1, 0xe1, 0x10, //0x000009a6 shlq         $16, %rcx
+	0x49, 0x09, 0xcd, //0x000009aa orq          %rcx, %r13
+	0x49, 0x09, 0xd5, //0x000009ad orq          %rdx, %r13
+	0x4d, 0x09, 0xcd, //0x000009b0 orq          %r9, %r13
+	0xc5, 0xe9, 0x74, 0xc1, //0x000009b3 vpcmpeqb     %xmm1, %xmm2, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc8, //0x000009b7 vpmovmskb    %xmm0, %ecx
+	0xc5, 0xd1, 0x74, 0xc1, //0x000009bb vpcmpeqb     %xmm1, %xmm5, %xmm0
+	0xc5, 0xf9, 0xd7, 0xd0, //0x000009bf vpmovmskb    %xmm0, %edx
+	0xc5, 0xc1, 0x74, 0xc1, //0x000009c3 vpcmpeqb     %xmm1, %xmm7, %xmm0
+	0xc5, 0x79, 0xd7, 0xc8, //0x000009c7 vpmovmskb    %xmm0, %r9d
+	0xc5, 0xc9, 0x74, 0xc1, //0x000009cb vpcmpeqb     %xmm1, %xmm6, %xmm0
+	0xc5, 0x79, 0xd7, 0xd0, //0x000009cf vpmovmskb    %xmm0, %r10d
+	0x49, 0xc1, 0xe2, 0x30, //0x000009d3 shlq         $48, %r10
+	0x49, 0xc1, 0xe1, 0x20, //0x000009d7 shlq         $32, %r9
+	0x48, 0xc1, 0xe2, 0x10, //0x000009db shlq         $16, %rdx
+	0x48, 0x09, 0xd1, //0x000009df orq          %rdx, %rcx
+	0x4c, 0x09, 0xc9, //0x000009e2 orq          %r9, %rcx
+	0x4c, 0x09, 0xd1, //0x000009e5 orq          %r10, %rcx
+	0x48, 0x89, 0xca, //0x000009e8 movq         %rcx, %rdx
+	0x48, 0x09, 0xda, //0x000009eb orq          %rbx, %rdx
+	0x0f, 0x84, 0x49, 0x00, 0x00, 0x00, //0x000009ee je           LBB0_87
+	0x48, 0x89, 0xda, //0x000009f4 movq         %rbx, %rdx
+	0x48, 0xf7, 0xd2, //0x000009f7 notq         %rdx
+	0x48, 0x21, 0xca, //0x000009fa andq         %rcx, %rdx
+	0x4c, 0x8d, 0x0c, 0x12, //0x000009fd leaq         (%rdx,%rdx), %r9
+	0x49, 0x09, 0xd9, //0x00000a01 orq          %rbx, %r9
+	0x4d, 0x89, 0xca, //0x00000a04 movq         %r9, %r10
+	0x48, 0xbb, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, //0x00000a07 movabsq      $-6148914691236517206, %rbx
+	0x49, 0x31, 0xda, //0x00000a11 xorq         %rbx, %r10
+	0x48, 0x21, 0xd9, //0x00000a14 andq         %rbx, %rcx
+	0x4c, 0x21, 0xd1, //0x00000a17 andq         %r10, %rcx
+	0x31, 0xdb, //0x00000a1a xorl         %ebx, %ebx
+	0x48, 0x01, 0xd1, //0x00000a1c addq         %rdx, %rcx
+	0x0f, 0x92, 0xc3, //0x00000a1f setb         %bl
+	0x48, 0x01, 0xc9, //0x00000a22 addq         %rcx, %rcx
+	0x48, 0xba, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, //0x00000a25 movabsq      $6148914691236517205, %rdx
+	0x48, 0x31, 0xd1, //0x00000a2f xorq         %rdx, %rcx
+	0x4c, 0x21, 0xc9, //0x00000a32 andq         %r9, %rcx
+	0x48, 0xf7, 0xd1, //0x00000a35 notq         %rcx
+	0xe9, 0x09, 0x00, 0x00, 0x00, //0x00000a38 jmp          LBB0_88
+	//0x00000a3d LBB0_87
+	0x48, 0xc7, 0xc1, 0xff, 0xff, 0xff, 0xff, //0x00000a3d movq         $-1, %rcx
+	0x31, 0xdb, //0x00000a44 xorl         %ebx, %ebx
+	//0x00000a46 LBB0_88
+	0x48, 0x89, 0x5c, 0x24, 0x18, //0x00000a46 movq         %rbx, $24(%rsp)
+	0x4c, 0x21, 0xe9, //0x00000a4b andq         %r13, %rcx
+	0xc4, 0xe1, 0xf9, 0x6e, 0xc1, //0x00000a4e vmovq        %rcx, %xmm0
+	0xc4, 0xc3, 0x79, 0x44, 0xc1, 0x00, //0x00000a53 vpclmulqdq   $0, %xmm9, %xmm0, %xmm0
+	0xc4, 0xc1, 0xf9, 0x7e, 0xc5, //0x00000a59 vmovq        %xmm0, %r13
+	0x4d, 0x31, 0xe5, //0x00000a5e xorq         %r12, %r13
+	0xc5, 0xe9, 0x74, 0xc3, //0x00000a61 vpcmpeqb     %xmm3, %xmm2, %xmm0
+	0xc5, 0x79, 0xd7, 0xd0, //0x00000a65 vpmovmskb    %xmm0, %r10d
+	0xc5, 0xd1, 0x74, 0xc3, //0x00000a69 vpcmpeqb     %xmm3, %xmm5, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc8, //0x00000a6d vpmovmskb    %xmm0, %ecx
+	0xc5, 0xc1, 0x74, 0xc3, //0x00000a71 vpcmpeqb     %xmm3, %xmm7, %xmm0
+	0xc5, 0xf9, 0xd7, 0xd0, //0x00000a75 vpmovmskb    %xmm0, %edx
+	0xc5, 0xc9, 0x74, 0xc3, //0x00000a79 vpcmpeqb     %xmm3, %xmm6, %xmm0
+	0xc5, 0x79, 0xd7, 0xc8, //0x00000a7d vpmovmskb    %xmm0, %r9d
+	0x49, 0xc1, 0xe1, 0x30, //0x00000a81 shlq         $48, %r9
+	0x48, 0xc1, 0xe2, 0x20, //0x00000a85 shlq         $32, %rdx
+	0x48, 0xc1, 0xe1, 0x10, //0x00000a89 shlq         $16, %rcx
+	0x49, 0x09, 0xca, //0x00000a8d orq          %rcx, %r10
+	0x49, 0x09, 0xd2, //0x00000a90 orq          %rdx, %r10
+	0x4d, 0x09, 0xca, //0x00000a93 orq          %r9, %r10
+	0x4d, 0x89, 0xe9, //0x00000a96 movq         %r13, %r9
+	0x49, 0xf7, 0xd1, //0x00000a99 notq         %r9
+	0x4d, 0x21, 0xca, //0x00000a9c andq         %r9, %r10
+	0xc5, 0xe9, 0x74, 0xc4, //0x00000a9f vpcmpeqb     %xmm4, %xmm2, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc8, //0x00000aa3 vpmovmskb    %xmm0, %ecx
+	0xc5, 0xd1, 0x74, 0xc4, //0x00000aa7 vpcmpeqb     %xmm4, %xmm5, %xmm0
+	0xc5, 0xf9, 0xd7, 0xd0, //0x00000aab vpmovmskb    %xmm0, %edx
+	0xc5, 0xc1, 0x74, 0xc4, //0x00000aaf vpcmpeqb     %xmm4, %xmm7, %xmm0
+	0xc5, 0x79, 0xd7, 0xc0, //0x00000ab3 vpmovmskb    %xmm0, %r8d
+	0xc5, 0xc9, 0x74, 0xc4, //0x00000ab7 vpcmpeqb     %xmm4, %xmm6, %xmm0
+	0xc5, 0x79, 0xd7, 0xe0, //0x00000abb vpmovmskb    %xmm0, %r12d
+	0x49, 0xc1, 0xe4, 0x30, //0x00000abf shlq         $48, %r12
+	0x49, 0xc1, 0xe0, 0x20, //0x00000ac3 shlq         $32, %r8
+	0x48, 0xc1, 0xe2, 0x10, //0x00000ac7 shlq         $16, %rdx
+	0x48, 0x09, 0xd1, //0x00000acb orq          %rdx, %rcx
+	0x4c, 0x09, 0xc1, //0x00000ace orq          %r8, %rcx
+	0x4c, 0x09, 0xe1, //0x00000ad1 orq          %r12, %rcx
+	0x4c, 0x21, 0xc9, //0x00000ad4 andq         %r9, %rcx
+	0x0f, 0x84, 0x3f, 0x00, 0x00, 0x00, //0x00000ad7 je           LBB0_92
+	0x4c, 0x8b, 0x44, 0x24, 0x10, //0x00000add movq         $16(%rsp), %r8
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000ae2 .p2align 4, 0x90
+	//0x00000af0 LBB0_90
+	0x48, 0x8d, 0x59, 0xff, //0x00000af0 leaq         $-1(%rcx), %rbx
+	0x48, 0x89, 0xda, //0x00000af4 movq         %rbx, %rdx
+	0x4c, 0x21, 0xd2, //0x00000af7 andq         %r10, %rdx
+	0xf3, 0x48, 0x0f, 0xb8, 0xd2, //0x00000afa popcntq      %rdx, %rdx
+	0x4c, 0x01, 0xc2, //0x00000aff addq         %r8, %rdx
+	0x4c, 0x39, 0xfa, //0x00000b02 cmpq         %r15, %rdx
+	0x0f, 0x86, 0x50, 0x00, 0x00, 0x00, //0x00000b05 jbe          LBB0_109
+	0x49, 0xff, 0xc7, //0x00000b0b incq         %r15
+	0x48, 0x21, 0xd9, //0x00000b0e andq         %rbx, %rcx
+	0x0f, 0x85, 0xd9, 0xff, 0xff, 0xff, //0x00000b11 jne          LBB0_90
+	0xe9, 0x05, 0x00, 0x00, 0x00, //0x00000b17 jmp          LBB0_93
+	//0x00000b1c LBB0_92
+	0x4c, 0x8b, 0x44, 0x24, 0x10, //0x00000b1c movq         $16(%rsp), %r8
+	//0x00000b21 LBB0_93
+	0x49, 0xc1, 0xfd, 0x3f, //0x00000b21 sarq         $63, %r13
+	0xf3, 0x49, 0x0f, 0xb8, 0xca, //0x00000b25 popcntq      %r10, %rcx
+	0x49, 0x01, 0xc8, //0x00000b2a addq         %rcx, %r8
+	0x49, 0x83, 0xc6, 0x40, //0x00000b2d addq         $64, %r14
+	0x48, 0x8b, 0x4c, 0x24, 0x08, //0x00000b31 movq         $8(%rsp), %rcx
+	0x48, 0x83, 0xc1, 0xc0, //0x00000b36 addq         $-64, %rcx
+	0x4d, 0x89, 0xec, //0x00000b3a movq         %r13, %r12
+	0x48, 0x8b, 0x5c, 0x24, 0x18, //0x00000b3d movq         $24(%rsp), %rbx
+	0x48, 0x83, 0xf9, 0x40, //0x00000b42 cmpq         $64, %rcx
+	0x48, 0x89, 0x4c, 0x24, 0x08, //0x00000b46 movq         %rcx, $8(%rsp)
+	0x4c, 0x89, 0x44, 0x24, 0x10, //0x00000b4b movq         %r8, $16(%rsp)
+	0x0f, 0x8d, 0x11, 0xfe, 0xff, 0xff, //0x00000b50 jge          LBB0_85
+	0xe9, 0xd9, 0xfc, 0xff, 0xff, //0x00000b56 jmp          LBB0_94
+	//0x00000b5b LBB0_109
+	0x48, 0x8b, 0x47, 0x08, //0x00000b5b movq         $8(%rdi), %rax
+	0x48, 0x0f, 0xbc, 0xc9, //0x00000b5f bsfq         %rcx, %rcx
+	0x48, 0x2b, 0x4c, 0x24, 0x08, //0x00000b63 subq         $8(%rsp), %rcx
+	0x48, 0x8d, 0x44, 0x01, 0x01, //0x00000b68 leaq         $1(%rcx,%rax), %rax
+	0x48, 0x89, 0x06, //0x00000b6d movq         %rax, (%rsi)
+	0x48, 0x8b, 0x4f, 0x08, //0x00000b70 movq         $8(%rdi), %rcx
+	0x48, 0x39, 0xc8, //0x00000b74 cmpq         %rcx, %rax
+	0x48, 0x0f, 0x47, 0xc1, //0x00000b77 cmovaq       %rcx, %rax
+	0x48, 0x89, 0x06, //0x00000b7b movq         %rax, (%rsi)
+	0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000b7e movq         $-1, %rax
+	0x4c, 0x0f, 0x47, 0xd8, //0x00000b85 cmovaq       %rax, %r11
+	0xe9, 0x7d, 0xf7, 0xff, 0xff, //0x00000b89 jmp          LBB0_44
+	//0x00000b8e LBB0_54
+	0x4d, 0x85, 0xe4, //0x00000b8e testq        %r12, %r12
+	0x0f, 0x85, 0x8e, 0x00, 0x00, 0x00, //0x00000b91 jne          LBB0_119
+	0x4b, 0x8d, 0x5c, 0x17, 0x01, //0x00000b97 leaq         $1(%r15,%r10), %rbx
+	0x49, 0xf7, 0xd7, //0x00000b9c notq         %r15
+	0x4d, 0x01, 0xc7, //0x00000b9f addq         %r8, %r15
+	//0x00000ba2 LBB0_56
+	0x4d, 0x85, 0xff, //0x00000ba2 testq        %r15, %r15
+	0x0f, 0x8f, 0x24, 0x00, 0x00, 0x00, //0x00000ba5 jg           LBB0_113
+	0xe9, 0x5e, 0xf7, 0xff, 0xff, //0x00000bab jmp          LBB0_45
+	//0x00000bb0 LBB0_111
+	0x48, 0xc7, 0xc1, 0xfe, 0xff, 0xff, 0xff, //0x00000bb0 movq         $-2, %rcx
+	0xb8, 0x02, 0x00, 0x00, 0x00, //0x00000bb7 movl         $2, %eax
+	0x48, 0x01, 0xc3, //0x00000bbc addq         %rax, %rbx
+	0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000bbf movq         $-1, %rax
+	0x49, 0x01, 0xcf, //0x00000bc6 addq         %rcx, %r15
+	0x0f, 0x8e, 0x3f, 0xf7, 0xff, 0xff, //0x00000bc9 jle          LBB0_45
+	//0x00000bcf LBB0_113
+	0x0f, 0xb6, 0x03, //0x00000bcf movzbl       (%rbx), %eax
+	0x3c, 0x5c, //0x00000bd2 cmpb         $92, %al
+	0x0f, 0x84, 0xd6, 0xff, 0xff, 0xff, //0x00000bd4 je           LBB0_111
+	0x3c, 0x22, //0x00000bda cmpb         $34, %al
+	0x0f, 0x84, 0x24, 0x00, 0x00, 0x00, //0x00000bdc je           LBB0_116
+	0x48, 0xc7, 0xc1, 0xff, 0xff, 0xff, 0xff, //0x00000be2 movq         $-1, %rcx
+	0xb8, 0x01, 0x00, 0x00, 0x00, //0x00000be9 movl         $1, %eax
+	0x48, 0x01, 0xc3, //0x00000bee addq         %rax, %rbx
+	0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000bf1 movq         $-1, %rax
+	0x49, 0x01, 0xcf, //0x00000bf8 addq         %rcx, %r15
+	0x0f, 0x8f, 0xce, 0xff, 0xff, 0xff, //0x00000bfb jg           LBB0_113
+	0xe9, 0x08, 0xf7, 0xff, 0xff, //0x00000c01 jmp          LBB0_45
+	//0x00000c06 LBB0_116
+	0x4c, 0x29, 0xf3, //0x00000c06 subq         %r14, %rbx
+	0x48, 0xff, 0xc3, //0x00000c09 incq         %rbx
+	0xe9, 0xf7, 0xf6, 0xff, 0xff, //0x00000c0c jmp          LBB0_43
+	//0x00000c11 LBB0_117
+	0x4c, 0x01, 0xf3, //0x00000c11 addq         %r14, %rbx
+	0xe9, 0x89, 0xff, 0xff, 0xff, //0x00000c14 jmp          LBB0_56
+	//0x00000c19 LBB0_118
+	0x48, 0x8b, 0x4f, 0x08, //0x00000c19 movq         $8(%rdi), %rcx
+	0x48, 0x89, 0x0e, //0x00000c1d movq         %rcx, (%rsi)
+	0xe9, 0xe9, 0xf6, 0xff, 0xff, //0x00000c20 jmp          LBB0_45
+	//0x00000c25 LBB0_119
+	0x49, 0x8d, 0x48, 0xff, //0x00000c25 leaq         $-1(%r8), %rcx
+	0x4c, 0x39, 0xf9, //0x00000c29 cmpq         %r15, %rcx
+	0x0f, 0x84, 0xdc, 0xf6, 0xff, 0xff, //0x00000c2c je           LBB0_45
+	0x4b, 0x8d, 0x5c, 0x17, 0x02, //0x00000c32 leaq         $2(%r15,%r10), %rbx
+	0x4d, 0x29, 0xf8, //0x00000c37 subq         %r15, %r8
+	0x49, 0x83, 0xc0, 0xfe, //0x00000c3a addq         $-2, %r8
+	0x4d, 0x89, 0xc7, //0x00000c3e movq         %r8, %r15
+	0xe9, 0x5c, 0xff, 0xff, 0xff, //0x00000c41 jmp          LBB0_56
+	0x90, 0x90, //0x00000c46 .p2align 2, 0x90
+	// // .set L0_0_set_45, LBB0_45-LJTI0_0
+	// // .set L0_0_set_47, LBB0_47-LJTI0_0
+	// // .set L0_0_set_48, LBB0_48-LJTI0_0
+	// // .set L0_0_set_29, LBB0_29-LJTI0_0
+	// // .set L0_0_set_57, LBB0_57-LJTI0_0
+	// // .set L0_0_set_82, LBB0_82-LJTI0_0
+	// // .set L0_0_set_46, LBB0_46-LJTI0_0
+	// // .set L0_0_set_84, LBB0_84-LJTI0_0
+	//0x00000c48 LJTI0_0
+	0xc6, 0xf6, 0xff, 0xff, //0x00000c48 .long L0_0_set_45
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c4c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c50 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c54 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c58 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c5c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c60 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c64 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c68 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c6c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c70 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c74 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c78 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c7c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c80 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c84 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c88 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c8c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c90 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c94 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c98 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000c9c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000ca0 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000ca4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000ca8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cac .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cb0 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cb4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cb8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cbc .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cc0 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cc4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cc8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000ccc .long L0_0_set_47
+	0xfa, 0xf6, 0xff, 0xff, //0x00000cd0 .long L0_0_set_48
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cd4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cd8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cdc .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000ce0 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000ce4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000ce8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cec .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cf0 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cf4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000cf8 .long L0_0_set_47
+	0xe3, 0xf5, 0xff, 0xff, //0x00000cfc .long L0_0_set_29
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d00 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d04 .long L0_0_set_47
+	0xe3, 0xf5, 0xff, 0xff, //0x00000d08 .long L0_0_set_29
+	0xe3, 0xf5, 0xff, 0xff, //0x00000d0c .long L0_0_set_29
+	0xe3, 0xf5, 0xff, 0xff, //0x00000d10 .long L0_0_set_29
+	0xe3, 0xf5, 0xff, 0xff, //0x00000d14 .long L0_0_set_29
+	0xe3, 0xf5, 0xff, 0xff, //0x00000d18 .long L0_0_set_29
+	0xe3, 0xf5, 0xff, 0xff, //0x00000d1c .long L0_0_set_29
+	0xe3, 0xf5, 0xff, 0xff, //0x00000d20 .long L0_0_set_29
+	0xe3, 0xf5, 0xff, 0xff, //0x00000d24 .long L0_0_set_29
+	0xe3, 0xf5, 0xff, 0xff, //0x00000d28 .long L0_0_set_29
+	0xe3, 0xf5, 0xff, 0xff, //0x00000d2c .long L0_0_set_29
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d30 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d34 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d38 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d3c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d40 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d44 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d48 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d4c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d50 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d54 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d58 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d5c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d60 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d64 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d68 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d6c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d70 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d74 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d78 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d7c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d80 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d84 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d88 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d8c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d90 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d94 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d98 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000d9c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000da0 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000da4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000da8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dac .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000db0 .long L0_0_set_47
+	0x0a, 0xf8, 0xff, 0xff, //0x00000db4 .long L0_0_set_57
+	0xeb, 0xf6, 0xff, 0xff, //0x00000db8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dbc .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dc0 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dc4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dc8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dcc .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dd0 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dd4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dd8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000ddc .long L0_0_set_47
+	0x83, 0xfb, 0xff, 0xff, //0x00000de0 .long L0_0_set_82
+	0xeb, 0xf6, 0xff, 0xff, //0x00000de4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000de8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dec .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000df0 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000df4 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000df8 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000dfc .long L0_0_set_47
+	0xd8, 0xf6, 0xff, 0xff, //0x00000e00 .long L0_0_set_46
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e04 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e08 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e0c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e10 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e14 .long L0_0_set_47
+	0xd8, 0xf6, 0xff, 0xff, //0x00000e18 .long L0_0_set_46
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e1c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e20 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e24 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e28 .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e2c .long L0_0_set_47
+	0xeb, 0xf6, 0xff, 0xff, //0x00000e30 .long L0_0_set_47
+	0x99, 0xfb, 0xff, 0xff, //0x00000e34 .long L0_0_set_84
+	//0x00000e38 .p2align 2, 0x00
+	//0x00000e38 _MASK_USE_NUMBER
+	0x02, 0x00, 0x00, 0x00, //0x00000e38 .long 2
+}
+ 

vendor/github.com/bytedance/sonic/internal/native/avx/skip_one_subr.go

@@ -0,0 +1,46 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__skip_one = 144
+)
+
+const (
+    _stack__skip_one = 160
+)
+
+const (
+    _size__skip_one = 9472
+)
+
+var (
+    _pcsp__skip_one = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {9044, 160},
+        {9048, 48},
+        {9049, 40},
+        {9051, 32},
+        {9053, 24},
+        {9055, 16},
+        {9057, 8},
+        {9058, 0},
+        {9472, 160},
+    }
+)
+
+var _cfunc_skip_one = []loader.CFunc{
+    {"_skip_one_entry", 0,  _entry__skip_one, 0, nil},
+    {"_skip_one", _entry__skip_one, _size__skip_one, _stack__skip_one, _pcsp__skip_one},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/u64toa.go

@@ -0,0 +1,36 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_u64toa func(out unsafe.Pointer, val uint64) (ret int)
+
+var S_u64toa uintptr
+
+//go:nosplit
+func u64toa(out *byte, val uint64) (ret int) {
+    return F_u64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}

vendor/github.com/bytedance/sonic/internal/native/avx/u64toa_subr.go

@@ -0,0 +1,39 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__u64toa = 64
+)
+
+const (
+    _stack__u64toa = 8
+)
+
+const (
+    _size__u64toa = 1232
+)
+
+var (
+    _pcsp__u64toa = [][2]uint32{
+        {1, 0},
+        {161, 8},
+        {162, 0},
+        {457, 8},
+        {458, 0},
+        {756, 8},
+        {757, 0},
+        {1221, 8},
+        {1223, 0},
+    }
+)
+
+var _cfunc_u64toa = []loader.CFunc{
+    {"_u64toa_entry", 0,  _entry__u64toa, 0, nil},
+    {"_u64toa", _entry__u64toa, _size__u64toa, _stack__u64toa, _pcsp__u64toa},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/u64toa_text_amd64.go

@@ -0,0 +1,371 @@
+// +build amd64
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+var _text_u64toa = []byte{
+	// .p2align 4, 0x00
+	// LCPI0_0
+	0x59, 0x17, 0xb7, 0xd1, 0x00, 0x00, 0x00, 0x00, // .quad 3518437209
+	0x59, 0x17, 0xb7, 0xd1, 0x00, 0x00, 0x00, 0x00, //0x00000008 .quad 3518437209
+	//0x00000010 LCPI0_3
+	0x0a, 0x00, //0x00000010 .word 10
+	0x0a, 0x00, //0x00000012 .word 10
+	0x0a, 0x00, //0x00000014 .word 10
+	0x0a, 0x00, //0x00000016 .word 10
+	0x0a, 0x00, //0x00000018 .word 10
+	0x0a, 0x00, //0x0000001a .word 10
+	0x0a, 0x00, //0x0000001c .word 10
+	0x0a, 0x00, //0x0000001e .word 10
+	//0x00000020 LCPI0_4
+	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, //0x00000020 QUAD $0x3030303030303030; QUAD $0x3030303030303030  // .space 16, '0000000000000000'
+	//0x00000030 .p2align 3, 0x00
+	//0x00000030 LCPI0_1
+	0xc5, 0x20, 0x7b, 0x14, 0x34, 0x33, 0x00, 0x80, //0x00000030 .quad -9223315738079846203
+	//0x00000038 LCPI0_2
+	0x80, 0x00, 0x00, 0x08, 0x00, 0x20, 0x00, 0x80, //0x00000038 .quad -9223336852348469120
+	//0x00000040 .p2align 4, 0x90
+	//0x00000040 _u64toa
+	0x55, //0x00000040 pushq        %rbp
+	0x48, 0x89, 0xe5, //0x00000041 movq         %rsp, %rbp
+	0x48, 0x81, 0xfe, 0x0f, 0x27, 0x00, 0x00, //0x00000044 cmpq         $9999, %rsi
+	0x0f, 0x87, 0xa2, 0x00, 0x00, 0x00, //0x0000004b ja           LBB0_8
+	0x0f, 0xb7, 0xc6, //0x00000051 movzwl       %si, %eax
+	0xc1, 0xe8, 0x02, //0x00000054 shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x00000057 imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x0000005d shrl         $17, %eax
+	0x48, 0x8d, 0x14, 0x00, //0x00000060 leaq         (%rax,%rax), %rdx
+	0x6b, 0xc0, 0x64, //0x00000064 imull        $100, %eax, %eax
+	0x89, 0xf1, //0x00000067 movl         %esi, %ecx
+	0x29, 0xc1, //0x00000069 subl         %eax, %ecx
+	0x0f, 0xb7, 0xc1, //0x0000006b movzwl       %cx, %eax
+	0x48, 0x01, 0xc0, //0x0000006e addq         %rax, %rax
+	0x81, 0xfe, 0xe8, 0x03, 0x00, 0x00, //0x00000071 cmpl         $1000, %esi
+	0x0f, 0x82, 0x16, 0x00, 0x00, 0x00, //0x00000077 jb           LBB0_3
+	0x48, 0x8d, 0x0d, 0x8c, 0x04, 0x00, 0x00, //0x0000007d leaq         $1164(%rip), %rcx  /* _Digits+0(%rip) */
+	0x8a, 0x0c, 0x0a, //0x00000084 movb         (%rdx,%rcx), %cl
+	0x88, 0x0f, //0x00000087 movb         %cl, (%rdi)
+	0xb9, 0x01, 0x00, 0x00, 0x00, //0x00000089 movl         $1, %ecx
+	0xe9, 0x0b, 0x00, 0x00, 0x00, //0x0000008e jmp          LBB0_4
+	//0x00000093 LBB0_3
+	0x31, 0xc9, //0x00000093 xorl         %ecx, %ecx
+	0x83, 0xfe, 0x64, //0x00000095 cmpl         $100, %esi
+	0x0f, 0x82, 0x45, 0x00, 0x00, 0x00, //0x00000098 jb           LBB0_5
+	//0x0000009e LBB0_4
+	0x0f, 0xb7, 0xd2, //0x0000009e movzwl       %dx, %edx
+	0x48, 0x83, 0xca, 0x01, //0x000000a1 orq          $1, %rdx
+	0x48, 0x8d, 0x35, 0x64, 0x04, 0x00, 0x00, //0x000000a5 leaq         $1124(%rip), %rsi  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x32, //0x000000ac movb         (%rdx,%rsi), %dl
+	0x89, 0xce, //0x000000af movl         %ecx, %esi
+	0xff, 0xc1, //0x000000b1 incl         %ecx
+	0x88, 0x14, 0x37, //0x000000b3 movb         %dl, (%rdi,%rsi)
+	//0x000000b6 LBB0_6
+	0x48, 0x8d, 0x15, 0x53, 0x04, 0x00, 0x00, //0x000000b6 leaq         $1107(%rip), %rdx  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x10, //0x000000bd movb         (%rax,%rdx), %dl
+	0x89, 0xce, //0x000000c0 movl         %ecx, %esi
+	0xff, 0xc1, //0x000000c2 incl         %ecx
+	0x88, 0x14, 0x37, //0x000000c4 movb         %dl, (%rdi,%rsi)
+	//0x000000c7 LBB0_7
+	0x0f, 0xb7, 0xc0, //0x000000c7 movzwl       %ax, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x000000ca orq          $1, %rax
+	0x48, 0x8d, 0x15, 0x3b, 0x04, 0x00, 0x00, //0x000000ce leaq         $1083(%rip), %rdx  /* _Digits+0(%rip) */
+	0x8a, 0x04, 0x10, //0x000000d5 movb         (%rax,%rdx), %al
+	0x89, 0xca, //0x000000d8 movl         %ecx, %edx
+	0xff, 0xc1, //0x000000da incl         %ecx
+	0x88, 0x04, 0x17, //0x000000dc movb         %al, (%rdi,%rdx)
+	0x89, 0xc8, //0x000000df movl         %ecx, %eax
+	0x5d, //0x000000e1 popq         %rbp
+	0xc3, //0x000000e2 retq         
+	//0x000000e3 LBB0_5
+	0x31, 0xc9, //0x000000e3 xorl         %ecx, %ecx
+	0x83, 0xfe, 0x0a, //0x000000e5 cmpl         $10, %esi
+	0x0f, 0x83, 0xc8, 0xff, 0xff, 0xff, //0x000000e8 jae          LBB0_6
+	0xe9, 0xd4, 0xff, 0xff, 0xff, //0x000000ee jmp          LBB0_7
+	//0x000000f3 LBB0_8
+	0x48, 0x81, 0xfe, 0xff, 0xe0, 0xf5, 0x05, //0x000000f3 cmpq         $99999999, %rsi
+	0x0f, 0x87, 0x1e, 0x01, 0x00, 0x00, //0x000000fa ja           LBB0_16
+	0x89, 0xf0, //0x00000100 movl         %esi, %eax
+	0xba, 0x59, 0x17, 0xb7, 0xd1, //0x00000102 movl         $3518437209, %edx
+	0x48, 0x0f, 0xaf, 0xd0, //0x00000107 imulq        %rax, %rdx
+	0x48, 0xc1, 0xea, 0x2d, //0x0000010b shrq         $45, %rdx
+	0x44, 0x69, 0xc2, 0x10, 0x27, 0x00, 0x00, //0x0000010f imull        $10000, %edx, %r8d
+	0x89, 0xf1, //0x00000116 movl         %esi, %ecx
+	0x44, 0x29, 0xc1, //0x00000118 subl         %r8d, %ecx
+	0x4c, 0x69, 0xd0, 0x83, 0xde, 0x1b, 0x43, //0x0000011b imulq        $1125899907, %rax, %r10
+	0x49, 0xc1, 0xea, 0x31, //0x00000122 shrq         $49, %r10
+	0x41, 0x83, 0xe2, 0xfe, //0x00000126 andl         $-2, %r10d
+	0x0f, 0xb7, 0xc2, //0x0000012a movzwl       %dx, %eax
+	0xc1, 0xe8, 0x02, //0x0000012d shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x00000130 imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x00000136 shrl         $17, %eax
+	0x6b, 0xc0, 0x64, //0x00000139 imull        $100, %eax, %eax
+	0x29, 0xc2, //0x0000013c subl         %eax, %edx
+	0x44, 0x0f, 0xb7, 0xca, //0x0000013e movzwl       %dx, %r9d
+	0x4d, 0x01, 0xc9, //0x00000142 addq         %r9, %r9
+	0x0f, 0xb7, 0xc1, //0x00000145 movzwl       %cx, %eax
+	0xc1, 0xe8, 0x02, //0x00000148 shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x0000014b imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x00000151 shrl         $17, %eax
+	0x4c, 0x8d, 0x04, 0x00, //0x00000154 leaq         (%rax,%rax), %r8
+	0x6b, 0xc0, 0x64, //0x00000158 imull        $100, %eax, %eax
+	0x29, 0xc1, //0x0000015b subl         %eax, %ecx
+	0x44, 0x0f, 0xb7, 0xd9, //0x0000015d movzwl       %cx, %r11d
+	0x4d, 0x01, 0xdb, //0x00000161 addq         %r11, %r11
+	0x81, 0xfe, 0x80, 0x96, 0x98, 0x00, //0x00000164 cmpl         $10000000, %esi
+	0x0f, 0x82, 0x17, 0x00, 0x00, 0x00, //0x0000016a jb           LBB0_11
+	0x48, 0x8d, 0x05, 0x99, 0x03, 0x00, 0x00, //0x00000170 leaq         $921(%rip), %rax  /* _Digits+0(%rip) */
+	0x41, 0x8a, 0x04, 0x02, //0x00000177 movb         (%r10,%rax), %al
+	0x88, 0x07, //0x0000017b movb         %al, (%rdi)
+	0xb9, 0x01, 0x00, 0x00, 0x00, //0x0000017d movl         $1, %ecx
+	0xe9, 0x0e, 0x00, 0x00, 0x00, //0x00000182 jmp          LBB0_12
+	//0x00000187 LBB0_11
+	0x31, 0xc9, //0x00000187 xorl         %ecx, %ecx
+	0x81, 0xfe, 0x40, 0x42, 0x0f, 0x00, //0x00000189 cmpl         $1000000, %esi
+	0x0f, 0x82, 0x76, 0x00, 0x00, 0x00, //0x0000018f jb           LBB0_13
+	//0x00000195 LBB0_12
+	0x44, 0x89, 0xd0, //0x00000195 movl         %r10d, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x00000198 orq          $1, %rax
+	0x48, 0x8d, 0x35, 0x6d, 0x03, 0x00, 0x00, //0x0000019c leaq         $877(%rip), %rsi  /* _Digits+0(%rip) */
+	0x8a, 0x04, 0x30, //0x000001a3 movb         (%rax,%rsi), %al
+	0x89, 0xce, //0x000001a6 movl         %ecx, %esi
+	0xff, 0xc1, //0x000001a8 incl         %ecx
+	0x88, 0x04, 0x37, //0x000001aa movb         %al, (%rdi,%rsi)
+	//0x000001ad LBB0_14
+	0x48, 0x8d, 0x05, 0x5c, 0x03, 0x00, 0x00, //0x000001ad leaq         $860(%rip), %rax  /* _Digits+0(%rip) */
+	0x41, 0x8a, 0x04, 0x01, //0x000001b4 movb         (%r9,%rax), %al
+	0x89, 0xce, //0x000001b8 movl         %ecx, %esi
+	0xff, 0xc1, //0x000001ba incl         %ecx
+	0x88, 0x04, 0x37, //0x000001bc movb         %al, (%rdi,%rsi)
+	//0x000001bf LBB0_15
+	0x41, 0x0f, 0xb7, 0xc1, //0x000001bf movzwl       %r9w, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x000001c3 orq          $1, %rax
+	0x48, 0x8d, 0x35, 0x42, 0x03, 0x00, 0x00, //0x000001c7 leaq         $834(%rip), %rsi  /* _Digits+0(%rip) */
+	0x8a, 0x04, 0x30, //0x000001ce movb         (%rax,%rsi), %al
+	0x89, 0xca, //0x000001d1 movl         %ecx, %edx
+	0x88, 0x04, 0x3a, //0x000001d3 movb         %al, (%rdx,%rdi)
+	0x41, 0x8a, 0x04, 0x30, //0x000001d6 movb         (%r8,%rsi), %al
+	0x88, 0x44, 0x3a, 0x01, //0x000001da movb         %al, $1(%rdx,%rdi)
+	0x41, 0x0f, 0xb7, 0xc0, //0x000001de movzwl       %r8w, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x000001e2 orq          $1, %rax
+	0x8a, 0x04, 0x30, //0x000001e6 movb         (%rax,%rsi), %al
+	0x88, 0x44, 0x3a, 0x02, //0x000001e9 movb         %al, $2(%rdx,%rdi)
+	0x41, 0x8a, 0x04, 0x33, //0x000001ed movb         (%r11,%rsi), %al
+	0x88, 0x44, 0x3a, 0x03, //0x000001f1 movb         %al, $3(%rdx,%rdi)
+	0x41, 0x0f, 0xb7, 0xc3, //0x000001f5 movzwl       %r11w, %eax
+	0x48, 0x83, 0xc8, 0x01, //0x000001f9 orq          $1, %rax
+	0x8a, 0x04, 0x30, //0x000001fd movb         (%rax,%rsi), %al
+	0x83, 0xc1, 0x05, //0x00000200 addl         $5, %ecx
+	0x88, 0x44, 0x3a, 0x04, //0x00000203 movb         %al, $4(%rdx,%rdi)
+	0x89, 0xc8, //0x00000207 movl         %ecx, %eax
+	0x5d, //0x00000209 popq         %rbp
+	0xc3, //0x0000020a retq         
+	//0x0000020b LBB0_13
+	0x31, 0xc9, //0x0000020b xorl         %ecx, %ecx
+	0x81, 0xfe, 0xa0, 0x86, 0x01, 0x00, //0x0000020d cmpl         $100000, %esi
+	0x0f, 0x83, 0x94, 0xff, 0xff, 0xff, //0x00000213 jae          LBB0_14
+	0xe9, 0xa1, 0xff, 0xff, 0xff, //0x00000219 jmp          LBB0_15
+	//0x0000021e LBB0_16
+	0x48, 0xb8, 0xff, 0xff, 0xc0, 0x6f, 0xf2, 0x86, 0x23, 0x00, //0x0000021e movabsq      $9999999999999999, %rax
+	0x48, 0x39, 0xc6, //0x00000228 cmpq         %rax, %rsi
+	0x0f, 0x87, 0x05, 0x01, 0x00, 0x00, //0x0000022b ja           LBB0_18
+	0x48, 0xb9, 0xfd, 0xce, 0x61, 0x84, 0x11, 0x77, 0xcc, 0xab, //0x00000231 movabsq      $-6067343680855748867, %rcx
+	0x48, 0x89, 0xf0, //0x0000023b movq         %rsi, %rax
+	0x48, 0xf7, 0xe1, //0x0000023e mulq         %rcx
+	0x48, 0xc1, 0xea, 0x1a, //0x00000241 shrq         $26, %rdx
+	0x69, 0xc2, 0x00, 0xe1, 0xf5, 0x05, //0x00000245 imull        $100000000, %edx, %eax
+	0x29, 0xc6, //0x0000024b subl         %eax, %esi
+	0xc5, 0xf9, 0x6e, 0xc2, //0x0000024d vmovd        %edx, %xmm0
+	0xc5, 0xfa, 0x6f, 0x0d, 0xa7, 0xfd, 0xff, 0xff, //0x00000251 vmovdqu      $-601(%rip), %xmm1  /* LCPI0_0+0(%rip) */
+	0xc5, 0xf9, 0xf4, 0xd1, //0x00000259 vpmuludq     %xmm1, %xmm0, %xmm2
+	0xc5, 0xe9, 0x73, 0xd2, 0x2d, //0x0000025d vpsrlq       $45, %xmm2, %xmm2
+	0xb8, 0x10, 0x27, 0x00, 0x00, //0x00000262 movl         $10000, %eax
+	0xc4, 0xe1, 0xf9, 0x6e, 0xd8, //0x00000267 vmovq        %rax, %xmm3
+	0xc5, 0xe9, 0xf4, 0xe3, //0x0000026c vpmuludq     %xmm3, %xmm2, %xmm4
+	0xc5, 0xf9, 0xfa, 0xc4, //0x00000270 vpsubd       %xmm4, %xmm0, %xmm0
+	0xc5, 0xe9, 0x61, 0xc0, //0x00000274 vpunpcklwd   %xmm0, %xmm2, %xmm0
+	0xc5, 0xf9, 0x73, 0xf0, 0x02, //0x00000278 vpsllq       $2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x70, 0xc0, 0x50, //0x0000027d vpshuflw     $80, %xmm0, %xmm0
+	0xc5, 0xf9, 0x70, 0xc0, 0x50, //0x00000282 vpshufd      $80, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x15, 0xa1, 0xfd, 0xff, 0xff, //0x00000287 vmovddup     $-607(%rip), %xmm2  /* LCPI0_1+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc2, //0x0000028f vpmulhuw     %xmm2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x25, 0x9d, 0xfd, 0xff, 0xff, //0x00000293 vmovddup     $-611(%rip), %xmm4  /* LCPI0_2+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc4, //0x0000029b vpmulhuw     %xmm4, %xmm0, %xmm0
+	0xc5, 0xfa, 0x6f, 0x2d, 0x69, 0xfd, 0xff, 0xff, //0x0000029f vmovdqu      $-663(%rip), %xmm5  /* LCPI0_3+0(%rip) */
+	0xc5, 0xf9, 0xd5, 0xf5, //0x000002a7 vpmullw      %xmm5, %xmm0, %xmm6
+	0xc5, 0xc9, 0x73, 0xf6, 0x10, //0x000002ab vpsllq       $16, %xmm6, %xmm6
+	0xc5, 0xf9, 0xf9, 0xc6, //0x000002b0 vpsubw       %xmm6, %xmm0, %xmm0
+	0xc5, 0xf9, 0x6e, 0xf6, //0x000002b4 vmovd        %esi, %xmm6
+	0xc5, 0xc9, 0xf4, 0xc9, //0x000002b8 vpmuludq     %xmm1, %xmm6, %xmm1
+	0xc5, 0xf1, 0x73, 0xd1, 0x2d, //0x000002bc vpsrlq       $45, %xmm1, %xmm1
+	0xc5, 0xf1, 0xf4, 0xdb, //0x000002c1 vpmuludq     %xmm3, %xmm1, %xmm3
+	0xc5, 0xc9, 0xfa, 0xdb, //0x000002c5 vpsubd       %xmm3, %xmm6, %xmm3
+	0xc5, 0xf1, 0x61, 0xcb, //0x000002c9 vpunpcklwd   %xmm3, %xmm1, %xmm1
+	0xc5, 0xf1, 0x73, 0xf1, 0x02, //0x000002cd vpsllq       $2, %xmm1, %xmm1
+	0xc5, 0xfb, 0x70, 0xc9, 0x50, //0x000002d2 vpshuflw     $80, %xmm1, %xmm1
+	0xc5, 0xf9, 0x70, 0xc9, 0x50, //0x000002d7 vpshufd      $80, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xca, //0x000002dc vpmulhuw     %xmm2, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xcc, //0x000002e0 vpmulhuw     %xmm4, %xmm1, %xmm1
+	0xc5, 0xf1, 0xd5, 0xd5, //0x000002e4 vpmullw      %xmm5, %xmm1, %xmm2
+	0xc5, 0xe9, 0x73, 0xf2, 0x10, //0x000002e8 vpsllq       $16, %xmm2, %xmm2
+	0xc5, 0xf1, 0xf9, 0xca, //0x000002ed vpsubw       %xmm2, %xmm1, %xmm1
+	0xc5, 0xf9, 0x67, 0xc1, //0x000002f1 vpackuswb    %xmm1, %xmm0, %xmm0
+	0xc5, 0xf9, 0xfc, 0x0d, 0x23, 0xfd, 0xff, 0xff, //0x000002f5 vpaddb       $-733(%rip), %xmm0, %xmm1  /* LCPI0_4+0(%rip) */
+	0xc5, 0xe9, 0xef, 0xd2, //0x000002fd vpxor        %xmm2, %xmm2, %xmm2
+	0xc5, 0xf9, 0x74, 0xc2, //0x00000301 vpcmpeqb     %xmm2, %xmm0, %xmm0
+	0xc5, 0xf9, 0xd7, 0xc0, //0x00000305 vpmovmskb    %xmm0, %eax
+	0x0d, 0x00, 0x80, 0x00, 0x00, //0x00000309 orl          $32768, %eax
+	0x35, 0xff, 0x7f, 0xff, 0xff, //0x0000030e xorl         $-32769, %eax
+	0x0f, 0xbc, 0xc0, //0x00000313 bsfl         %eax, %eax
+	0xb9, 0x10, 0x00, 0x00, 0x00, //0x00000316 movl         $16, %ecx
+	0x29, 0xc1, //0x0000031b subl         %eax, %ecx
+	0x48, 0xc1, 0xe0, 0x04, //0x0000031d shlq         $4, %rax
+	0x48, 0x8d, 0x15, 0xb8, 0x02, 0x00, 0x00, //0x00000321 leaq         $696(%rip), %rdx  /* _VecShiftShuffles+0(%rip) */
+	0xc4, 0xe2, 0x71, 0x00, 0x04, 0x10, //0x00000328 vpshufb      (%rax,%rdx), %xmm1, %xmm0
+	0xc5, 0xfa, 0x7f, 0x07, //0x0000032e vmovdqu      %xmm0, (%rdi)
+	0x89, 0xc8, //0x00000332 movl         %ecx, %eax
+	0x5d, //0x00000334 popq         %rbp
+	0xc3, //0x00000335 retq         
+	//0x00000336 LBB0_18
+	0x48, 0xb9, 0x57, 0x78, 0x13, 0xb1, 0x2f, 0x65, 0xa5, 0x39, //0x00000336 movabsq      $4153837486827862103, %rcx
+	0x48, 0x89, 0xf0, //0x00000340 movq         %rsi, %rax
+	0x48, 0xf7, 0xe1, //0x00000343 mulq         %rcx
+	0x48, 0xc1, 0xea, 0x33, //0x00000346 shrq         $51, %rdx
+	0x48, 0xb8, 0x00, 0x00, 0xc1, 0x6f, 0xf2, 0x86, 0x23, 0x00, //0x0000034a movabsq      $10000000000000000, %rax
+	0x48, 0x0f, 0xaf, 0xc2, //0x00000354 imulq        %rdx, %rax
+	0x48, 0x29, 0xc6, //0x00000358 subq         %rax, %rsi
+	0x83, 0xfa, 0x09, //0x0000035b cmpl         $9, %edx
+	0x0f, 0x87, 0x0f, 0x00, 0x00, 0x00, //0x0000035e ja           LBB0_20
+	0x80, 0xc2, 0x30, //0x00000364 addb         $48, %dl
+	0x88, 0x17, //0x00000367 movb         %dl, (%rdi)
+	0xb9, 0x01, 0x00, 0x00, 0x00, //0x00000369 movl         $1, %ecx
+	0xe9, 0xba, 0x00, 0x00, 0x00, //0x0000036e jmp          LBB0_25
+	//0x00000373 LBB0_20
+	0x83, 0xfa, 0x63, //0x00000373 cmpl         $99, %edx
+	0x0f, 0x87, 0x1f, 0x00, 0x00, 0x00, //0x00000376 ja           LBB0_22
+	0x89, 0xd0, //0x0000037c movl         %edx, %eax
+	0x48, 0x8d, 0x0d, 0x8b, 0x01, 0x00, 0x00, //0x0000037e leaq         $395(%rip), %rcx  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x41, //0x00000385 movb         (%rcx,%rax,2), %dl
+	0x8a, 0x44, 0x41, 0x01, //0x00000388 movb         $1(%rcx,%rax,2), %al
+	0x88, 0x17, //0x0000038c movb         %dl, (%rdi)
+	0x88, 0x47, 0x01, //0x0000038e movb         %al, $1(%rdi)
+	0xb9, 0x02, 0x00, 0x00, 0x00, //0x00000391 movl         $2, %ecx
+	0xe9, 0x92, 0x00, 0x00, 0x00, //0x00000396 jmp          LBB0_25
+	//0x0000039b LBB0_22
+	0x89, 0xd0, //0x0000039b movl         %edx, %eax
+	0xc1, 0xe8, 0x02, //0x0000039d shrl         $2, %eax
+	0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x000003a0 imull        $5243, %eax, %eax
+	0xc1, 0xe8, 0x11, //0x000003a6 shrl         $17, %eax
+	0x81, 0xfa, 0xe7, 0x03, 0x00, 0x00, //0x000003a9 cmpl         $999, %edx
+	0x0f, 0x87, 0x3c, 0x00, 0x00, 0x00, //0x000003af ja           LBB0_24
+	0x83, 0xc0, 0x30, //0x000003b5 addl         $48, %eax
+	0x88, 0x07, //0x000003b8 movb         %al, (%rdi)
+	0x0f, 0xb7, 0xc2, //0x000003ba movzwl       %dx, %eax
+	0x89, 0xc1, //0x000003bd movl         %eax, %ecx
+	0xc1, 0xe9, 0x02, //0x000003bf shrl         $2, %ecx
+	0x69, 0xc9, 0x7b, 0x14, 0x00, 0x00, //0x000003c2 imull        $5243, %ecx, %ecx
+	0xc1, 0xe9, 0x11, //0x000003c8 shrl         $17, %ecx
+	0x6b, 0xc9, 0x64, //0x000003cb imull        $100, %ecx, %ecx
+	0x29, 0xc8, //0x000003ce subl         %ecx, %eax
+	0x0f, 0xb7, 0xc0, //0x000003d0 movzwl       %ax, %eax
+	0x48, 0x8d, 0x0d, 0x36, 0x01, 0x00, 0x00, //0x000003d3 leaq         $310(%rip), %rcx  /* _Digits+0(%rip) */
+	0x8a, 0x14, 0x41, //0x000003da movb         (%rcx,%rax,2), %dl
+	0x8a, 0x44, 0x41, 0x01, //0x000003dd movb         $1(%rcx,%rax,2), %al
+	0x88, 0x57, 0x01, //0x000003e1 movb         %dl, $1(%rdi)
+	0x88, 0x47, 0x02, //0x000003e4 movb         %al, $2(%rdi)
+	0xb9, 0x03, 0x00, 0x00, 0x00, //0x000003e7 movl         $3, %ecx
+	0xe9, 0x3c, 0x00, 0x00, 0x00, //0x000003ec jmp          LBB0_25
+	//0x000003f1 LBB0_24
+	0x6b, 0xc8, 0x64, //0x000003f1 imull        $100, %eax, %ecx
+	0x29, 0xca, //0x000003f4 subl         %ecx, %edx
+	0x0f, 0xb7, 0xc0, //0x000003f6 movzwl       %ax, %eax
+	0x4c, 0x8d, 0x05, 0x10, 0x01, 0x00, 0x00, //0x000003f9 leaq         $272(%rip), %r8  /* _Digits+0(%rip) */
+	0x41, 0x8a, 0x0c, 0x40, //0x00000400 movb         (%r8,%rax,2), %cl
+	0x41, 0x8a, 0x44, 0x40, 0x01, //0x00000404 movb         $1(%r8,%rax,2), %al
+	0x88, 0x0f, //0x00000409 movb         %cl, (%rdi)
+	0x88, 0x47, 0x01, //0x0000040b movb         %al, $1(%rdi)
+	0x0f, 0xb7, 0xc2, //0x0000040e movzwl       %dx, %eax
+	0x41, 0x8a, 0x0c, 0x40, //0x00000411 movb         (%r8,%rax,2), %cl
+	0x48, 0x01, 0xc0, //0x00000415 addq         %rax, %rax
+	0x88, 0x4f, 0x02, //0x00000418 movb         %cl, $2(%rdi)
+	0x83, 0xc8, 0x01, //0x0000041b orl          $1, %eax
+	0x0f, 0xb7, 0xc0, //0x0000041e movzwl       %ax, %eax
+	0x42, 0x8a, 0x04, 0x00, //0x00000421 movb         (%rax,%r8), %al
+	0x88, 0x47, 0x03, //0x00000425 movb         %al, $3(%rdi)
+	0xb9, 0x04, 0x00, 0x00, 0x00, //0x00000428 movl         $4, %ecx
+	//0x0000042d LBB0_25
+	0x48, 0xba, 0xfd, 0xce, 0x61, 0x84, 0x11, 0x77, 0xcc, 0xab, //0x0000042d movabsq      $-6067343680855748867, %rdx
+	0x48, 0x89, 0xf0, //0x00000437 movq         %rsi, %rax
+	0x48, 0xf7, 0xe2, //0x0000043a mulq         %rdx
+	0x48, 0xc1, 0xea, 0x1a, //0x0000043d shrq         $26, %rdx
+	0xc5, 0xf9, 0x6e, 0xc2, //0x00000441 vmovd        %edx, %xmm0
+	0xc5, 0xfa, 0x6f, 0x0d, 0xb3, 0xfb, 0xff, 0xff, //0x00000445 vmovdqu      $-1101(%rip), %xmm1  /* LCPI0_0+0(%rip) */
+	0xc5, 0xf9, 0xf4, 0xd1, //0x0000044d vpmuludq     %xmm1, %xmm0, %xmm2
+	0xc5, 0xe9, 0x73, 0xd2, 0x2d, //0x00000451 vpsrlq       $45, %xmm2, %xmm2
+	0xb8, 0x10, 0x27, 0x00, 0x00, //0x00000456 movl         $10000, %eax
+	0xc4, 0xe1, 0xf9, 0x6e, 0xd8, //0x0000045b vmovq        %rax, %xmm3
+	0xc5, 0xe9, 0xf4, 0xe3, //0x00000460 vpmuludq     %xmm3, %xmm2, %xmm4
+	0xc5, 0xf9, 0xfa, 0xc4, //0x00000464 vpsubd       %xmm4, %xmm0, %xmm0
+	0xc5, 0xe9, 0x61, 0xc0, //0x00000468 vpunpcklwd   %xmm0, %xmm2, %xmm0
+	0xc5, 0xf9, 0x73, 0xf0, 0x02, //0x0000046c vpsllq       $2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x70, 0xc0, 0x50, //0x00000471 vpshuflw     $80, %xmm0, %xmm0
+	0xc5, 0xf9, 0x70, 0xc0, 0x50, //0x00000476 vpshufd      $80, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x15, 0xad, 0xfb, 0xff, 0xff, //0x0000047b vmovddup     $-1107(%rip), %xmm2  /* LCPI0_1+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc2, //0x00000483 vpmulhuw     %xmm2, %xmm0, %xmm0
+	0xc5, 0xfb, 0x12, 0x25, 0xa9, 0xfb, 0xff, 0xff, //0x00000487 vmovddup     $-1111(%rip), %xmm4  /* LCPI0_2+0(%rip) */
+	0xc5, 0xf9, 0xe4, 0xc4, //0x0000048f vpmulhuw     %xmm4, %xmm0, %xmm0
+	0xc5, 0xfa, 0x6f, 0x2d, 0x75, 0xfb, 0xff, 0xff, //0x00000493 vmovdqu      $-1163(%rip), %xmm5  /* LCPI0_3+0(%rip) */
+	0xc5, 0xf9, 0xd5, 0xf5, //0x0000049b vpmullw      %xmm5, %xmm0, %xmm6
+	0xc5, 0xc9, 0x73, 0xf6, 0x10, //0x0000049f vpsllq       $16, %xmm6, %xmm6
+	0xc5, 0xf9, 0xf9, 0xc6, //0x000004a4 vpsubw       %xmm6, %xmm0, %xmm0
+	0x69, 0xc2, 0x00, 0xe1, 0xf5, 0x05, //0x000004a8 imull        $100000000, %edx, %eax
+	0x29, 0xc6, //0x000004ae subl         %eax, %esi
+	0xc5, 0xf9, 0x6e, 0xf6, //0x000004b0 vmovd        %esi, %xmm6
+	0xc5, 0xc9, 0xf4, 0xc9, //0x000004b4 vpmuludq     %xmm1, %xmm6, %xmm1
+	0xc5, 0xf1, 0x73, 0xd1, 0x2d, //0x000004b8 vpsrlq       $45, %xmm1, %xmm1
+	0xc5, 0xf1, 0xf4, 0xdb, //0x000004bd vpmuludq     %xmm3, %xmm1, %xmm3
+	0xc5, 0xc9, 0xfa, 0xdb, //0x000004c1 vpsubd       %xmm3, %xmm6, %xmm3
+	0xc5, 0xf1, 0x61, 0xcb, //0x000004c5 vpunpcklwd   %xmm3, %xmm1, %xmm1
+	0xc5, 0xf1, 0x73, 0xf1, 0x02, //0x000004c9 vpsllq       $2, %xmm1, %xmm1
+	0xc5, 0xfb, 0x70, 0xc9, 0x50, //0x000004ce vpshuflw     $80, %xmm1, %xmm1
+	0xc5, 0xf9, 0x70, 0xc9, 0x50, //0x000004d3 vpshufd      $80, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xca, //0x000004d8 vpmulhuw     %xmm2, %xmm1, %xmm1
+	0xc5, 0xf1, 0xe4, 0xcc, //0x000004dc vpmulhuw     %xmm4, %xmm1, %xmm1
+	0xc5, 0xf1, 0xd5, 0xd5, //0x000004e0 vpmullw      %xmm5, %xmm1, %xmm2
+	0xc5, 0xe9, 0x73, 0xf2, 0x10, //0x000004e4 vpsllq       $16, %xmm2, %xmm2
+	0xc5, 0xf1, 0xf9, 0xca, //0x000004e9 vpsubw       %xmm2, %xmm1, %xmm1
+	0xc5, 0xf9, 0x67, 0xc1, //0x000004ed vpackuswb    %xmm1, %xmm0, %xmm0
+	0xc5, 0xf9, 0xfc, 0x05, 0x27, 0xfb, 0xff, 0xff, //0x000004f1 vpaddb       $-1241(%rip), %xmm0, %xmm0  /* LCPI0_4+0(%rip) */
+	0x89, 0xc8, //0x000004f9 movl         %ecx, %eax
+	0xc5, 0xfa, 0x7f, 0x04, 0x07, //0x000004fb vmovdqu      %xmm0, (%rdi,%rax)
+	0x83, 0xc9, 0x10, //0x00000500 orl          $16, %ecx
+	0x89, 0xc8, //0x00000503 movl         %ecx, %eax
+	0x5d, //0x00000505 popq         %rbp
+	0xc3, //0x00000506 retq         
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000507 .p2align 4, 0x00
+	//0x00000510 _Digits
+	0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x35, 0x30, 0x36, 0x30, 0x37, //0x00000510 QUAD $0x3330323031303030; QUAD $0x3730363035303430  // .ascii 16, '0001020304050607'
+	0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x31, 0x31, 0x31, 0x32, 0x31, 0x33, 0x31, 0x34, 0x31, 0x35, //0x00000520 QUAD $0x3131303139303830; QUAD $0x3531343133313231  // .ascii 16, '0809101112131415'
+	0x31, 0x36, 0x31, 0x37, 0x31, 0x38, 0x31, 0x39, 0x32, 0x30, 0x32, 0x31, 0x32, 0x32, 0x32, 0x33, //0x00000530 QUAD $0x3931383137313631; QUAD $0x3332323231323032  // .ascii 16, '1617181920212223'
+	0x32, 0x34, 0x32, 0x35, 0x32, 0x36, 0x32, 0x37, 0x32, 0x38, 0x32, 0x39, 0x33, 0x30, 0x33, 0x31, //0x00000540 QUAD $0x3732363235323432; QUAD $0x3133303339323832  // .ascii 16, '2425262728293031'
+	0x33, 0x32, 0x33, 0x33, 0x33, 0x34, 0x33, 0x35, 0x33, 0x36, 0x33, 0x37, 0x33, 0x38, 0x33, 0x39, //0x00000550 QUAD $0x3533343333333233; QUAD $0x3933383337333633  // .ascii 16, '3233343536373839'
+	0x34, 0x30, 0x34, 0x31, 0x34, 0x32, 0x34, 0x33, 0x34, 0x34, 0x34, 0x35, 0x34, 0x36, 0x34, 0x37, //0x00000560 QUAD $0x3334323431343034; QUAD $0x3734363435343434  // .ascii 16, '4041424344454647'
+	0x34, 0x38, 0x34, 0x39, 0x35, 0x30, 0x35, 0x31, 0x35, 0x32, 0x35, 0x33, 0x35, 0x34, 0x35, 0x35, //0x00000570 QUAD $0x3135303539343834; QUAD $0x3535343533353235  // .ascii 16, '4849505152535455'
+	0x35, 0x36, 0x35, 0x37, 0x35, 0x38, 0x35, 0x39, 0x36, 0x30, 0x36, 0x31, 0x36, 0x32, 0x36, 0x33, //0x00000580 QUAD $0x3935383537353635; QUAD $0x3336323631363036  // .ascii 16, '5657585960616263'
+	0x36, 0x34, 0x36, 0x35, 0x36, 0x36, 0x36, 0x37, 0x36, 0x38, 0x36, 0x39, 0x37, 0x30, 0x37, 0x31, //0x00000590 QUAD $0x3736363635363436; QUAD $0x3137303739363836  // .ascii 16, '6465666768697071'
+	0x37, 0x32, 0x37, 0x33, 0x37, 0x34, 0x37, 0x35, 0x37, 0x36, 0x37, 0x37, 0x37, 0x38, 0x37, 0x39, //0x000005a0 QUAD $0x3537343733373237; QUAD $0x3937383737373637  // .ascii 16, '7273747576777879'
+	0x38, 0x30, 0x38, 0x31, 0x38, 0x32, 0x38, 0x33, 0x38, 0x34, 0x38, 0x35, 0x38, 0x36, 0x38, 0x37, //0x000005b0 QUAD $0x3338323831383038; QUAD $0x3738363835383438  // .ascii 16, '8081828384858687'
+	0x38, 0x38, 0x38, 0x39, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x34, 0x39, 0x35, //0x000005c0 QUAD $0x3139303939383838; QUAD $0x3539343933393239  // .ascii 16, '8889909192939495'
+	0x39, 0x36, 0x39, 0x37, 0x39, 0x38, 0x39, 0x39, //0x000005d0 QUAD $0x3939383937393639  // .ascii 8, '96979899'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000005d8 .p2align 4, 0x00
+	//0x000005e0 _VecShiftShuffles
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, //0x000005e0 QUAD $0x0706050403020100; QUAD $0x0f0e0d0c0b0a0908  // .ascii 16, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'
+	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, //0x000005f0 QUAD $0x0807060504030201; QUAD $0xff0f0e0d0c0b0a09  // .ascii 16, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff'
+	0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, //0x00000600 QUAD $0x0908070605040302; QUAD $0xffff0f0e0d0c0b0a  // .ascii 16, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff'
+	0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, //0x00000610 QUAD $0x0a09080706050403; QUAD $0xffffff0f0e0d0c0b  // .ascii 16, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff'
+	0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, //0x00000620 QUAD $0x0b0a090807060504; QUAD $0xffffffff0f0e0d0c  // .ascii 16, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff'
+	0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000630 QUAD $0x0c0b0a0908070605; QUAD $0xffffffffff0f0e0d  // .ascii 16, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff'
+	0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000640 QUAD $0x0d0c0b0a09080706; QUAD $0xffffffffffff0f0e  // .ascii 16, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff'
+	0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000650 QUAD $0x0e0d0c0b0a090807; QUAD $0xffffffffffffff0f  // .ascii 16, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff'
+	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000660 QUAD $0x0f0e0d0c0b0a0908; QUAD $0xffffffffffffffff  // .ascii 16, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff'
+}
+ 

vendor/github.com/bytedance/sonic/internal/native/avx/unquote.go

@@ -0,0 +1,36 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_unquote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep unsafe.Pointer, flags uint64) (ret int)
+
+var S_unquote uintptr
+
+//go:nosplit
+func unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) {
+    return F_unquote(rt.NoEscape(sp), nb, dp, rt.NoEscape(unsafe.Pointer(ep)), flags)
+}

vendor/github.com/bytedance/sonic/internal/native/avx/unquote_subr.go

@@ -0,0 +1,46 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__unquote = 16
+)
+
+const (
+    _stack__unquote = 88
+)
+
+const (
+    _size__unquote = 2272
+)
+
+var (
+    _pcsp__unquote = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1684, 88},
+        {1688, 48},
+        {1689, 40},
+        {1691, 32},
+        {1693, 24},
+        {1695, 16},
+        {1697, 8},
+        {1698, 0},
+        {2270, 88},
+    }
+)
+
+var _cfunc_unquote = []loader.CFunc{
+    {"_unquote_entry", 0,  _entry__unquote, 0, nil},
+    {"_unquote", _entry__unquote, _size__unquote, _stack__unquote, _pcsp__unquote},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/unquote_text_amd64.go

@@ -0,0 +1,639 @@
+// +build amd64
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+var _text_unquote = []byte{
+	// .p2align 4, 0x00
+	// LCPI0_0
+	0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, // QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c  // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+	//0x00000010 .p2align 4, 0x90
+	//0x00000010 _unquote
+	0x55, //0x00000010 pushq        %rbp
+	0x48, 0x89, 0xe5, //0x00000011 movq         %rsp, %rbp
+	0x41, 0x57, //0x00000014 pushq        %r15
+	0x41, 0x56, //0x00000016 pushq        %r14
+	0x41, 0x55, //0x00000018 pushq        %r13
+	0x41, 0x54, //0x0000001a pushq        %r12
+	0x53, //0x0000001c pushq        %rbx
+	0x48, 0x83, 0xec, 0x28, //0x0000001d subq         $40, %rsp
+	0x48, 0x85, 0xf6, //0x00000021 testq        %rsi, %rsi
+	0x0f, 0x84, 0x6e, 0x06, 0x00, 0x00, //0x00000024 je           LBB0_82
+	0x49, 0x89, 0xf3, //0x0000002a movq         %rsi, %r11
+	0x48, 0x89, 0x4d, 0xc8, //0x0000002d movq         %rcx, $-56(%rbp)
+	0x4c, 0x89, 0xc0, //0x00000031 movq         %r8, %rax
+	0x4c, 0x89, 0x45, 0xb8, //0x00000034 movq         %r8, $-72(%rbp)
+	0x45, 0x89, 0xc2, //0x00000038 movl         %r8d, %r10d
+	0x41, 0x83, 0xe2, 0x01, //0x0000003b andl         $1, %r10d
+	0x4c, 0x8d, 0x05, 0xaa, 0x08, 0x00, 0x00, //0x0000003f leaq         $2218(%rip), %r8  /* __UnquoteTab+0(%rip) */
+	0xc5, 0xfa, 0x6f, 0x05, 0xb2, 0xff, 0xff, 0xff, //0x00000046 vmovdqu      $-78(%rip), %xmm0  /* LCPI0_0+0(%rip) */
+	0x49, 0x89, 0xf9, //0x0000004e movq         %rdi, %r9
+	0x49, 0x89, 0xf5, //0x00000051 movq         %rsi, %r13
+	0x48, 0x89, 0xd0, //0x00000054 movq         %rdx, %rax
+	//0x00000057 LBB0_2
+	0x41, 0x80, 0x39, 0x5c, //0x00000057 cmpb         $92, (%r9)
+	0x0f, 0x85, 0x0f, 0x00, 0x00, 0x00, //0x0000005b jne          LBB0_4
+	0x31, 0xf6, //0x00000061 xorl         %esi, %esi
+	0xe9, 0xc8, 0x00, 0x00, 0x00, //0x00000063 jmp          LBB0_13
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000068 .p2align 4, 0x90
+	//0x00000070 LBB0_4
+	0x4d, 0x89, 0xef, //0x00000070 movq         %r13, %r15
+	0x48, 0x89, 0xc6, //0x00000073 movq         %rax, %rsi
+	0x4d, 0x89, 0xce, //0x00000076 movq         %r9, %r14
+	0x49, 0x83, 0xfd, 0x10, //0x00000079 cmpq         $16, %r13
+	0x0f, 0x8c, 0x3d, 0x00, 0x00, 0x00, //0x0000007d jl           LBB0_7
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000083 .p2align 4, 0x90
+	//0x00000090 LBB0_5
+	0xc4, 0xc1, 0x7a, 0x6f, 0x0e, //0x00000090 vmovdqu      (%r14), %xmm1
+	0xc5, 0xfa, 0x7f, 0x0e, //0x00000095 vmovdqu      %xmm1, (%rsi)
+	0xc5, 0xf1, 0x74, 0xc8, //0x00000099 vpcmpeqb     %xmm0, %xmm1, %xmm1
+	0xc5, 0xf9, 0xd7, 0xd9, //0x0000009d vpmovmskb    %xmm1, %ebx
+	0x66, 0x85, 0xdb, //0x000000a1 testw        %bx, %bx
+	0x0f, 0x85, 0x60, 0x00, 0x00, 0x00, //0x000000a4 jne          LBB0_12
+	0x49, 0x83, 0xc6, 0x10, //0x000000aa addq         $16, %r14
+	0x48, 0x83, 0xc6, 0x10, //0x000000ae addq         $16, %rsi
+	0x49, 0x83, 0xff, 0x1f, //0x000000b2 cmpq         $31, %r15
+	0x4d, 0x8d, 0x7f, 0xf0, //0x000000b6 leaq         $-16(%r15), %r15
+	0x0f, 0x8f, 0xd0, 0xff, 0xff, 0xff, //0x000000ba jg           LBB0_5
+	//0x000000c0 LBB0_7
+	0x4d, 0x85, 0xff, //0x000000c0 testq        %r15, %r15
+	0x0f, 0x84, 0xd5, 0x05, 0x00, 0x00, //0x000000c3 je           LBB0_83
+	0x31, 0xdb, //0x000000c9 xorl         %ebx, %ebx
+	0x90, 0x90, 0x90, 0x90, 0x90, //0x000000cb .p2align 4, 0x90
+	//0x000000d0 LBB0_9
+	0x41, 0x0f, 0xb6, 0x0c, 0x1e, //0x000000d0 movzbl       (%r14,%rbx), %ecx
+	0x80, 0xf9, 0x5c, //0x000000d5 cmpb         $92, %cl
+	0x0f, 0x84, 0x14, 0x00, 0x00, 0x00, //0x000000d8 je           LBB0_11
+	0x88, 0x0c, 0x1e, //0x000000de movb         %cl, (%rsi,%rbx)
+	0x48, 0xff, 0xc3, //0x000000e1 incq         %rbx
+	0x49, 0x39, 0xdf, //0x000000e4 cmpq         %rbx, %r15
+	0x0f, 0x85, 0xe3, 0xff, 0xff, 0xff, //0x000000e7 jne          LBB0_9
+	0xe9, 0xac, 0x05, 0x00, 0x00, //0x000000ed jmp          LBB0_83
+	//0x000000f2 LBB0_11
+	0x49, 0x01, 0xde, //0x000000f2 addq         %rbx, %r14
+	0x4d, 0x29, 0xce, //0x000000f5 subq         %r9, %r14
+	0x4c, 0x89, 0xf6, //0x000000f8 movq         %r14, %rsi
+	0x48, 0x83, 0xfe, 0xff, //0x000000fb cmpq         $-1, %rsi
+	0x0f, 0x85, 0x2b, 0x00, 0x00, 0x00, //0x000000ff jne          LBB0_13
+	0xe9, 0x94, 0x05, 0x00, 0x00, //0x00000105 jmp          LBB0_83
+	//0x0000010a LBB0_12
+	0x0f, 0xb7, 0xcb, //0x0000010a movzwl       %bx, %ecx
+	0x4d, 0x29, 0xce, //0x0000010d subq         %r9, %r14
+	0x48, 0x0f, 0xbc, 0xf1, //0x00000110 bsfq         %rcx, %rsi
+	0x4c, 0x01, 0xf6, //0x00000114 addq         %r14, %rsi
+	0x48, 0x83, 0xfe, 0xff, //0x00000117 cmpq         $-1, %rsi
+	0x0f, 0x84, 0x7d, 0x05, 0x00, 0x00, //0x0000011b je           LBB0_83
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000121 .p2align 4, 0x90
+	//0x00000130 LBB0_13
+	0x48, 0x8d, 0x4e, 0x02, //0x00000130 leaq         $2(%rsi), %rcx
+	0x49, 0x29, 0xcd, //0x00000134 subq         %rcx, %r13
+	0x0f, 0x88, 0x2a, 0x06, 0x00, 0x00, //0x00000137 js           LBB0_94
+	0x4d, 0x8d, 0x4c, 0x31, 0x02, //0x0000013d leaq         $2(%r9,%rsi), %r9
+	0x4d, 0x85, 0xd2, //0x00000142 testq        %r10, %r10
+	0x0f, 0x85, 0xe5, 0x03, 0x00, 0x00, //0x00000145 jne          LBB0_58
+	//0x0000014b LBB0_15
+	0x48, 0x01, 0xf0, //0x0000014b addq         %rsi, %rax
+	0x41, 0x0f, 0xb6, 0x49, 0xff, //0x0000014e movzbl       $-1(%r9), %ecx
+	0x42, 0x8a, 0x0c, 0x01, //0x00000153 movb         (%rcx,%r8), %cl
+	0x80, 0xf9, 0xff, //0x00000157 cmpb         $-1, %cl
+	0x0f, 0x84, 0x20, 0x00, 0x00, 0x00, //0x0000015a je           LBB0_18
+	0x84, 0xc9, //0x00000160 testb        %cl, %cl
+	0x0f, 0x84, 0x12, 0x06, 0x00, 0x00, //0x00000162 je           LBB0_95
+	0x88, 0x08, //0x00000168 movb         %cl, (%rax)
+	0x48, 0xff, 0xc0, //0x0000016a incq         %rax
+	0xe9, 0xb0, 0x03, 0x00, 0x00, //0x0000016d jmp          LBB0_57
+	0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000172 .p2align 4, 0x90
+	//0x00000180 LBB0_18
+	0x49, 0x83, 0xfd, 0x03, //0x00000180 cmpq         $3, %r13
+	0x0f, 0x8e, 0xdd, 0x05, 0x00, 0x00, //0x00000184 jle          LBB0_94
+	0x41, 0x8b, 0x31, //0x0000018a movl         (%r9), %esi
+	0x89, 0xf1, //0x0000018d movl         %esi, %ecx
+	0xf7, 0xd1, //0x0000018f notl         %ecx
+	0x8d, 0x9e, 0xd0, 0xcf, 0xcf, 0xcf, //0x00000191 leal         $-808464432(%rsi), %ebx
+	0x81, 0xe1, 0x80, 0x80, 0x80, 0x80, //0x00000197 andl         $-2139062144, %ecx
+	0x85, 0xd9, //0x0000019d testl        %ebx, %ecx
+	0x0f, 0x85, 0x0e, 0x05, 0x00, 0x00, //0x0000019f jne          LBB0_85
+	0x8d, 0x9e, 0x19, 0x19, 0x19, 0x19, //0x000001a5 leal         $421075225(%rsi), %ebx
+	0x09, 0xf3, //0x000001ab orl          %esi, %ebx
+	0xf7, 0xc3, 0x80, 0x80, 0x80, 0x80, //0x000001ad testl        $-2139062144, %ebx
+	0x0f, 0x85, 0xfa, 0x04, 0x00, 0x00, //0x000001b3 jne          LBB0_85
+	0x89, 0xf3, //0x000001b9 movl         %esi, %ebx
+	0x81, 0xe3, 0x7f, 0x7f, 0x7f, 0x7f, //0x000001bb andl         $2139062143, %ebx
+	0x41, 0xbe, 0xc0, 0xc0, 0xc0, 0xc0, //0x000001c1 movl         $-1061109568, %r14d
+	0x41, 0x29, 0xde, //0x000001c7 subl         %ebx, %r14d
+	0x44, 0x8d, 0xbb, 0x46, 0x46, 0x46, 0x46, //0x000001ca leal         $1179010630(%rbx), %r15d
+	0x41, 0x21, 0xce, //0x000001d1 andl         %ecx, %r14d
+	0x45, 0x85, 0xfe, //0x000001d4 testl        %r15d, %r14d
+	0x0f, 0x85, 0xd6, 0x04, 0x00, 0x00, //0x000001d7 jne          LBB0_85
+	0x41, 0xbe, 0xe0, 0xe0, 0xe0, 0xe0, //0x000001dd movl         $-522133280, %r14d
+	0x41, 0x29, 0xde, //0x000001e3 subl         %ebx, %r14d
+	0x81, 0xc3, 0x39, 0x39, 0x39, 0x39, //0x000001e6 addl         $960051513, %ebx
+	0x44, 0x21, 0xf1, //0x000001ec andl         %r14d, %ecx
+	0x85, 0xd9, //0x000001ef testl        %ebx, %ecx
+	0x0f, 0x85, 0xbc, 0x04, 0x00, 0x00, //0x000001f1 jne          LBB0_85
+	0x0f, 0xce, //0x000001f7 bswapl       %esi
+	0x89, 0xf1, //0x000001f9 movl         %esi, %ecx
+	0xc1, 0xe9, 0x04, //0x000001fb shrl         $4, %ecx
+	0xf7, 0xd1, //0x000001fe notl         %ecx
+	0x81, 0xe1, 0x01, 0x01, 0x01, 0x01, //0x00000200 andl         $16843009, %ecx
+	0x8d, 0x0c, 0xc9, //0x00000206 leal         (%rcx,%rcx,8), %ecx
+	0x81, 0xe6, 0x0f, 0x0f, 0x0f, 0x0f, //0x00000209 andl         $252645135, %esi
+	0x01, 0xce, //0x0000020f addl         %ecx, %esi
+	0x89, 0xf1, //0x00000211 movl         %esi, %ecx
+	0xc1, 0xe9, 0x04, //0x00000213 shrl         $4, %ecx
+	0x09, 0xf1, //0x00000216 orl          %esi, %ecx
+	0x44, 0x0f, 0xb6, 0xf9, //0x00000218 movzbl       %cl, %r15d
+	0xc1, 0xe9, 0x08, //0x0000021c shrl         $8, %ecx
+	0x81, 0xe1, 0x00, 0xff, 0x00, 0x00, //0x0000021f andl         $65280, %ecx
+	0x41, 0x09, 0xcf, //0x00000225 orl          %ecx, %r15d
+	0x4d, 0x8d, 0x75, 0xfc, //0x00000228 leaq         $-4(%r13), %r14
+	0x41, 0x81, 0xff, 0x80, 0x00, 0x00, 0x00, //0x0000022c cmpl         $128, %r15d
+	0x0f, 0x82, 0x46, 0x03, 0x00, 0x00, //0x00000233 jb           LBB0_66
+	0x45, 0x31, 0xe4, //0x00000239 xorl         %r12d, %r12d
+	0x4d, 0x85, 0xd2, //0x0000023c testq        %r10, %r10
+	0x0f, 0x84, 0x5b, 0x01, 0x00, 0x00, //0x0000023f je           LBB0_40
+	//0x00000245 LBB0_25
+	0x41, 0x81, 0xff, 0x00, 0x08, 0x00, 0x00, //0x00000245 cmpl         $2048, %r15d
+	0x0f, 0x82, 0x3c, 0x03, 0x00, 0x00, //0x0000024c jb           LBB0_68
+	0x44, 0x89, 0xf9, //0x00000252 movl         %r15d, %ecx
+	0x81, 0xe1, 0x00, 0xf8, 0xff, 0xff, //0x00000255 andl         $-2048, %ecx
+	0x81, 0xf9, 0x00, 0xd8, 0x00, 0x00, //0x0000025b cmpl         $55296, %ecx
+	0x0f, 0x85, 0x89, 0x02, 0x00, 0x00, //0x00000261 jne          LBB0_54
+	0x4d, 0x85, 0xf6, //0x00000267 testq        %r14, %r14
+	0x0f, 0x8e, 0x6b, 0x03, 0x00, 0x00, //0x0000026a jle          LBB0_72
+	0x43, 0x80, 0x7c, 0x21, 0x04, 0x5c, //0x00000270 cmpb         $92, $4(%r9,%r12)
+	0x0f, 0x85, 0x6e, 0x03, 0x00, 0x00, //0x00000276 jne          LBB0_73
+	0x41, 0x81, 0xff, 0xff, 0xdb, 0x00, 0x00, //0x0000027c cmpl         $56319, %r15d
+	0x0f, 0x87, 0x34, 0x03, 0x00, 0x00, //0x00000283 ja           LBB0_70
+	0x49, 0x83, 0xfe, 0x07, //0x00000289 cmpq         $7, %r14
+	0x0f, 0x8c, 0x2a, 0x03, 0x00, 0x00, //0x0000028d jl           LBB0_70
+	0x43, 0x80, 0x7c, 0x21, 0x05, 0x5c, //0x00000293 cmpb         $92, $5(%r9,%r12)
+	0x0f, 0x85, 0x1e, 0x03, 0x00, 0x00, //0x00000299 jne          LBB0_70
+	0x43, 0x80, 0x7c, 0x21, 0x06, 0x75, //0x0000029f cmpb         $117, $6(%r9,%r12)
+	0x0f, 0x85, 0x12, 0x03, 0x00, 0x00, //0x000002a5 jne          LBB0_70
+	0x43, 0x8b, 0x74, 0x21, 0x07, //0x000002ab movl         $7(%r9,%r12), %esi
+	0x89, 0xf1, //0x000002b0 movl         %esi, %ecx
+	0xf7, 0xd1, //0x000002b2 notl         %ecx
+	0x8d, 0x9e, 0xd0, 0xcf, 0xcf, 0xcf, //0x000002b4 leal         $-808464432(%rsi), %ebx
+	0x81, 0xe1, 0x80, 0x80, 0x80, 0x80, //0x000002ba andl         $-2139062144, %ecx
+	0x85, 0xd9, //0x000002c0 testl        %ebx, %ecx
+	0x0f, 0x85, 0xe8, 0x04, 0x00, 0x00, //0x000002c2 jne          LBB0_99
+	0x8d, 0x9e, 0x19, 0x19, 0x19, 0x19, //0x000002c8 leal         $421075225(%rsi), %ebx
+	0x09, 0xf3, //0x000002ce orl          %esi, %ebx
+	0xf7, 0xc3, 0x80, 0x80, 0x80, 0x80, //0x000002d0 testl        $-2139062144, %ebx
+	0x0f, 0x85, 0xd4, 0x04, 0x00, 0x00, //0x000002d6 jne          LBB0_99
+	0x89, 0xf3, //0x000002dc movl         %esi, %ebx
+	0x81, 0xe3, 0x7f, 0x7f, 0x7f, 0x7f, //0x000002de andl         $2139062143, %ebx
+	0xc7, 0x45, 0xd4, 0xc0, 0xc0, 0xc0, 0xc0, //0x000002e4 movl         $-1061109568, $-44(%rbp)
+	0x29, 0x5d, 0xd4, //0x000002eb subl         %ebx, $-44(%rbp)
+	0x48, 0x89, 0x75, 0xb0, //0x000002ee movq         %rsi, $-80(%rbp)
+	0x8d, 0xb3, 0x46, 0x46, 0x46, 0x46, //0x000002f2 leal         $1179010630(%rbx), %esi
+	0x89, 0x75, 0xc4, //0x000002f8 movl         %esi, $-60(%rbp)
+	0x21, 0x4d, 0xd4, //0x000002fb andl         %ecx, $-44(%rbp)
+	0x8b, 0x75, 0xc4, //0x000002fe movl         $-60(%rbp), %esi
+	0x85, 0x75, 0xd4, //0x00000301 testl        %esi, $-44(%rbp)
+	0x48, 0x8b, 0x75, 0xb0, //0x00000304 movq         $-80(%rbp), %rsi
+	0x0f, 0x85, 0xa2, 0x04, 0x00, 0x00, //0x00000308 jne          LBB0_99
+	0xc7, 0x45, 0xd4, 0xe0, 0xe0, 0xe0, 0xe0, //0x0000030e movl         $-522133280, $-44(%rbp)
+	0x29, 0x5d, 0xd4, //0x00000315 subl         %ebx, $-44(%rbp)
+	0x81, 0xc3, 0x39, 0x39, 0x39, 0x39, //0x00000318 addl         $960051513, %ebx
+	0x23, 0x4d, 0xd4, //0x0000031e andl         $-44(%rbp), %ecx
+	0x85, 0xd9, //0x00000321 testl        %ebx, %ecx
+	0x0f, 0x85, 0x87, 0x04, 0x00, 0x00, //0x00000323 jne          LBB0_99
+	0x0f, 0xce, //0x00000329 bswapl       %esi
+	0x89, 0xf1, //0x0000032b movl         %esi, %ecx
+	0xc1, 0xe9, 0x04, //0x0000032d shrl         $4, %ecx
+	0xf7, 0xd1, //0x00000330 notl         %ecx
+	0x81, 0xe1, 0x01, 0x01, 0x01, 0x01, //0x00000332 andl         $16843009, %ecx
+	0x8d, 0x0c, 0xc9, //0x00000338 leal         (%rcx,%rcx,8), %ecx
+	0x81, 0xe6, 0x0f, 0x0f, 0x0f, 0x0f, //0x0000033b andl         $252645135, %esi
+	0x01, 0xce, //0x00000341 addl         %ecx, %esi
+	0x89, 0xf1, //0x00000343 movl         %esi, %ecx
+	0xc1, 0xe9, 0x04, //0x00000345 shrl         $4, %ecx
+	0x09, 0xf1, //0x00000348 orl          %esi, %ecx
+	0x89, 0xce, //0x0000034a movl         %ecx, %esi
+	0xc1, 0xee, 0x08, //0x0000034c shrl         $8, %esi
+	0x81, 0xe6, 0x00, 0xff, 0x00, 0x00, //0x0000034f andl         $65280, %esi
+	0x0f, 0xb6, 0xd9, //0x00000355 movzbl       %cl, %ebx
+	0x09, 0xf3, //0x00000358 orl          %esi, %ebx
+	0x81, 0xe1, 0x00, 0x00, 0xfc, 0x00, //0x0000035a andl         $16515072, %ecx
+	0x81, 0xf9, 0x00, 0x00, 0xdc, 0x00, //0x00000360 cmpl         $14417920, %ecx
+	0x0f, 0x84, 0xac, 0x02, 0x00, 0x00, //0x00000366 je           LBB0_77
+	0xf6, 0x45, 0xb8, 0x02, //0x0000036c testb        $2, $-72(%rbp)
+	0x0f, 0x84, 0x41, 0x05, 0x00, 0x00, //0x00000370 je           LBB0_114
+	0x49, 0x83, 0xc6, 0xf9, //0x00000376 addq         $-7, %r14
+	0x66, 0xc7, 0x00, 0xef, 0xbf, //0x0000037a movw         $-16401, (%rax)
+	0xc6, 0x40, 0x02, 0xbd, //0x0000037f movb         $-67, $2(%rax)
+	0x48, 0x83, 0xc0, 0x03, //0x00000383 addq         $3, %rax
+	0x49, 0x83, 0xc4, 0x07, //0x00000387 addq         $7, %r12
+	0x41, 0x89, 0xdf, //0x0000038b movl         %ebx, %r15d
+	0x83, 0xfb, 0x7f, //0x0000038e cmpl         $127, %ebx
+	0x0f, 0x87, 0xae, 0xfe, 0xff, 0xff, //0x00000391 ja           LBB0_25
+	0xe9, 0x44, 0x01, 0x00, 0x00, //0x00000397 jmp          LBB0_53
+	0x90, 0x90, 0x90, 0x90, //0x0000039c .p2align 4, 0x90
+	//0x000003a0 LBB0_40
+	0x41, 0x81, 0xff, 0x00, 0x08, 0x00, 0x00, //0x000003a0 cmpl         $2048, %r15d
+	0x0f, 0x82, 0xe1, 0x01, 0x00, 0x00, //0x000003a7 jb           LBB0_68
+	0x44, 0x89, 0xf9, //0x000003ad movl         %r15d, %ecx
+	0x81, 0xe1, 0x00, 0xf8, 0xff, 0xff, //0x000003b0 andl         $-2048, %ecx
+	0x81, 0xf9, 0x00, 0xd8, 0x00, 0x00, //0x000003b6 cmpl         $55296, %ecx
+	0x0f, 0x85, 0x2e, 0x01, 0x00, 0x00, //0x000003bc jne          LBB0_54
+	0x41, 0x81, 0xff, 0xff, 0xdb, 0x00, 0x00, //0x000003c2 cmpl         $56319, %r15d
+	0x0f, 0x87, 0xe4, 0x01, 0x00, 0x00, //0x000003c9 ja           LBB0_69
+	0x49, 0x83, 0xfe, 0x06, //0x000003cf cmpq         $6, %r14
+	0x0f, 0x8c, 0xda, 0x01, 0x00, 0x00, //0x000003d3 jl           LBB0_69
+	0x43, 0x80, 0x7c, 0x21, 0x04, 0x5c, //0x000003d9 cmpb         $92, $4(%r9,%r12)
+	0x0f, 0x85, 0xce, 0x01, 0x00, 0x00, //0x000003df jne          LBB0_69
+	0x43, 0x80, 0x7c, 0x21, 0x05, 0x75, //0x000003e5 cmpb         $117, $5(%r9,%r12)
+	0x0f, 0x85, 0xc2, 0x01, 0x00, 0x00, //0x000003eb jne          LBB0_69
+	0x43, 0x8b, 0x74, 0x21, 0x06, //0x000003f1 movl         $6(%r9,%r12), %esi
+	0x89, 0xf1, //0x000003f6 movl         %esi, %ecx
+	0xf7, 0xd1, //0x000003f8 notl         %ecx
+	0x8d, 0x9e, 0xd0, 0xcf, 0xcf, 0xcf, //0x000003fa leal         $-808464432(%rsi), %ebx
+	0x81, 0xe1, 0x80, 0x80, 0x80, 0x80, //0x00000400 andl         $-2139062144, %ecx
+	0x85, 0xd9, //0x00000406 testl        %ebx, %ecx
+	0x0f, 0x85, 0x98, 0x03, 0x00, 0x00, //0x00000408 jne          LBB0_98
+	0x8d, 0x9e, 0x19, 0x19, 0x19, 0x19, //0x0000040e leal         $421075225(%rsi), %ebx
+	0x09, 0xf3, //0x00000414 orl          %esi, %ebx
+	0xf7, 0xc3, 0x80, 0x80, 0x80, 0x80, //0x00000416 testl        $-2139062144, %ebx
+	0x0f, 0x85, 0x84, 0x03, 0x00, 0x00, //0x0000041c jne          LBB0_98
+	0x89, 0xf3, //0x00000422 movl         %esi, %ebx
+	0x81, 0xe3, 0x7f, 0x7f, 0x7f, 0x7f, //0x00000424 andl         $2139062143, %ebx
+	0xc7, 0x45, 0xd4, 0xc0, 0xc0, 0xc0, 0xc0, //0x0000042a movl         $-1061109568, $-44(%rbp)
+	0x29, 0x5d, 0xd4, //0x00000431 subl         %ebx, $-44(%rbp)
+	0x48, 0x89, 0x75, 0xb0, //0x00000434 movq         %rsi, $-80(%rbp)
+	0x8d, 0xb3, 0x46, 0x46, 0x46, 0x46, //0x00000438 leal         $1179010630(%rbx), %esi
+	0x89, 0x75, 0xc4, //0x0000043e movl         %esi, $-60(%rbp)
+	0x21, 0x4d, 0xd4, //0x00000441 andl         %ecx, $-44(%rbp)
+	0x8b, 0x75, 0xc4, //0x00000444 movl         $-60(%rbp), %esi
+	0x85, 0x75, 0xd4, //0x00000447 testl        %esi, $-44(%rbp)
+	0x48, 0x8b, 0x75, 0xb0, //0x0000044a movq         $-80(%rbp), %rsi
+	0x0f, 0x85, 0x52, 0x03, 0x00, 0x00, //0x0000044e jne          LBB0_98
+	0xc7, 0x45, 0xd4, 0xe0, 0xe0, 0xe0, 0xe0, //0x00000454 movl         $-522133280, $-44(%rbp)
+	0x29, 0x5d, 0xd4, //0x0000045b subl         %ebx, $-44(%rbp)
+	0x81, 0xc3, 0x39, 0x39, 0x39, 0x39, //0x0000045e addl         $960051513, %ebx
+	0x23, 0x4d, 0xd4, //0x00000464 andl         $-44(%rbp), %ecx
+	0x85, 0xd9, //0x00000467 testl        %ebx, %ecx
+	0x0f, 0x85, 0x37, 0x03, 0x00, 0x00, //0x00000469 jne          LBB0_98
+	0x0f, 0xce, //0x0000046f bswapl       %esi
+	0x89, 0xf1, //0x00000471 movl         %esi, %ecx
+	0xc1, 0xe9, 0x04, //0x00000473 shrl         $4, %ecx
+	0xf7, 0xd1, //0x00000476 notl         %ecx
+	0x81, 0xe1, 0x01, 0x01, 0x01, 0x01, //0x00000478 andl         $16843009, %ecx
+	0x8d, 0x0c, 0xc9, //0x0000047e leal         (%rcx,%rcx,8), %ecx
+	0x81, 0xe6, 0x0f, 0x0f, 0x0f, 0x0f, //0x00000481 andl         $252645135, %esi
+	0x01, 0xce, //0x00000487 addl         %ecx, %esi
+	0x89, 0xf1, //0x00000489 movl         %esi, %ecx
+	0xc1, 0xe9, 0x04, //0x0000048b shrl         $4, %ecx
+	0x09, 0xf1, //0x0000048e orl          %esi, %ecx
+	0x89, 0xce, //0x00000490 movl         %ecx, %esi
+	0xc1, 0xee, 0x08, //0x00000492 shrl         $8, %esi
+	0x81, 0xe6, 0x00, 0xff, 0x00, 0x00, //0x00000495 andl         $65280, %esi
+	0x0f, 0xb6, 0xd9, //0x0000049b movzbl       %cl, %ebx
+	0x09, 0xf3, //0x0000049e orl          %esi, %ebx
+	0x81, 0xe1, 0x00, 0x00, 0xfc, 0x00, //0x000004a0 andl         $16515072, %ecx
+	0x81, 0xf9, 0x00, 0x00, 0xdc, 0x00, //0x000004a6 cmpl         $14417920, %ecx
+	0x0f, 0x84, 0x55, 0x01, 0x00, 0x00, //0x000004ac je           LBB0_76
+	0xf6, 0x45, 0xb8, 0x02, //0x000004b2 testb        $2, $-72(%rbp)
+	0x0f, 0x84, 0xf1, 0x03, 0x00, 0x00, //0x000004b6 je           LBB0_113
+	0x49, 0x83, 0xc6, 0xfa, //0x000004bc addq         $-6, %r14
+	0x66, 0xc7, 0x00, 0xef, 0xbf, //0x000004c0 movw         $-16401, (%rax)
+	0xc6, 0x40, 0x02, 0xbd, //0x000004c5 movb         $-67, $2(%rax)
+	0x48, 0x83, 0xc0, 0x03, //0x000004c9 addq         $3, %rax
+	0x49, 0x83, 0xc4, 0x06, //0x000004cd addq         $6, %r12
+	0x41, 0x89, 0xdf, //0x000004d1 movl         %ebx, %r15d
+	0x81, 0xfb, 0x80, 0x00, 0x00, 0x00, //0x000004d4 cmpl         $128, %ebx
+	0x0f, 0x83, 0xc0, 0xfe, 0xff, 0xff, //0x000004da jae          LBB0_40
+	//0x000004e0 LBB0_53
+	0x4f, 0x8d, 0x4c, 0x21, 0x04, //0x000004e0 leaq         $4(%r9,%r12), %r9
+	0x41, 0x89, 0xdf, //0x000004e5 movl         %ebx, %r15d
+	0xe9, 0x96, 0x00, 0x00, 0x00, //0x000004e8 jmp          LBB0_67
+	0x90, 0x90, 0x90, //0x000004ed .p2align 4, 0x90
+	//0x000004f0 LBB0_54
+	0x4f, 0x8d, 0x4c, 0x21, 0x04, //0x000004f0 leaq         $4(%r9,%r12), %r9
+	0x44, 0x89, 0xf9, //0x000004f5 movl         %r15d, %ecx
+	0xc1, 0xe9, 0x0c, //0x000004f8 shrl         $12, %ecx
+	0x80, 0xc9, 0xe0, //0x000004fb orb          $-32, %cl
+	0x88, 0x08, //0x000004fe movb         %cl, (%rax)
+	0x44, 0x89, 0xf9, //0x00000500 movl         %r15d, %ecx
+	0xc1, 0xe9, 0x06, //0x00000503 shrl         $6, %ecx
+	0x80, 0xe1, 0x3f, //0x00000506 andb         $63, %cl
+	0x80, 0xc9, 0x80, //0x00000509 orb          $-128, %cl
+	0x88, 0x48, 0x01, //0x0000050c movb         %cl, $1(%rax)
+	0x41, 0x80, 0xe7, 0x3f, //0x0000050f andb         $63, %r15b
+	0x41, 0x80, 0xcf, 0x80, //0x00000513 orb          $-128, %r15b
+	0x44, 0x88, 0x78, 0x02, //0x00000517 movb         %r15b, $2(%rax)
+	//0x0000051b LBB0_55
+	0x48, 0x83, 0xc0, 0x03, //0x0000051b addq         $3, %rax
+	//0x0000051f LBB0_56
+	0x4d, 0x89, 0xf5, //0x0000051f movq         %r14, %r13
+	//0x00000522 LBB0_57
+	0x4d, 0x85, 0xed, //0x00000522 testq        %r13, %r13
+	0x0f, 0x85, 0x2c, 0xfb, 0xff, 0xff, //0x00000525 jne          LBB0_2
+	0xe9, 0x63, 0x02, 0x00, 0x00, //0x0000052b jmp          LBB0_96
+	//0x00000530 LBB0_58
+	0x45, 0x85, 0xed, //0x00000530 testl        %r13d, %r13d
+	0x0f, 0x84, 0x2e, 0x02, 0x00, 0x00, //0x00000533 je           LBB0_94
+	0x41, 0x80, 0x79, 0xff, 0x5c, //0x00000539 cmpb         $92, $-1(%r9)
+	0x0f, 0x85, 0x57, 0x02, 0x00, 0x00, //0x0000053e jne          LBB0_97
+	0x41, 0x80, 0x39, 0x5c, //0x00000544 cmpb         $92, (%r9)
+	0x0f, 0x85, 0x26, 0x00, 0x00, 0x00, //0x00000548 jne          LBB0_65
+	0x41, 0x83, 0xfd, 0x01, //0x0000054e cmpl         $1, %r13d
+	0x0f, 0x8e, 0x0f, 0x02, 0x00, 0x00, //0x00000552 jle          LBB0_94
+	0x41, 0x8a, 0x49, 0x01, //0x00000558 movb         $1(%r9), %cl
+	0x80, 0xf9, 0x22, //0x0000055c cmpb         $34, %cl
+	0x0f, 0x84, 0x09, 0x00, 0x00, 0x00, //0x0000055f je           LBB0_64
+	0x80, 0xf9, 0x5c, //0x00000565 cmpb         $92, %cl
+	0x0f, 0x85, 0x0c, 0x03, 0x00, 0x00, //0x00000568 jne          LBB0_109
+	//0x0000056e LBB0_64
+	0x49, 0xff, 0xc1, //0x0000056e incq         %r9
+	0x49, 0xff, 0xcd, //0x00000571 decq         %r13
+	//0x00000574 LBB0_65
+	0x49, 0xff, 0xc1, //0x00000574 incq         %r9
+	0x49, 0xff, 0xcd, //0x00000577 decq         %r13
+	0xe9, 0xcc, 0xfb, 0xff, 0xff, //0x0000057a jmp          LBB0_15
+	//0x0000057f LBB0_66
+	0x49, 0x83, 0xc1, 0x04, //0x0000057f addq         $4, %r9
+	//0x00000583 LBB0_67
+	0x44, 0x88, 0x38, //0x00000583 movb         %r15b, (%rax)
+	0x48, 0xff, 0xc0, //0x00000586 incq         %rax
+	0xe9, 0x91, 0xff, 0xff, 0xff, //0x00000589 jmp          LBB0_56
+	//0x0000058e LBB0_68
+	0x4f, 0x8d, 0x4c, 0x21, 0x04, //0x0000058e leaq         $4(%r9,%r12), %r9
+	0x44, 0x89, 0xf9, //0x00000593 movl         %r15d, %ecx
+	0xc1, 0xe9, 0x06, //0x00000596 shrl         $6, %ecx
+	0x80, 0xc9, 0xc0, //0x00000599 orb          $-64, %cl
+	0x88, 0x08, //0x0000059c movb         %cl, (%rax)
+	0x41, 0x80, 0xe7, 0x3f, //0x0000059e andb         $63, %r15b
+	0x41, 0x80, 0xcf, 0x80, //0x000005a2 orb          $-128, %r15b
+	0x44, 0x88, 0x78, 0x01, //0x000005a6 movb         %r15b, $1(%rax)
+	0x48, 0x83, 0xc0, 0x02, //0x000005aa addq         $2, %rax
+	0xe9, 0x6c, 0xff, 0xff, 0xff, //0x000005ae jmp          LBB0_56
+	//0x000005b3 LBB0_69
+	0x4f, 0x8d, 0x4c, 0x21, 0x04, //0x000005b3 leaq         $4(%r9,%r12), %r9
+	0xe9, 0x0f, 0x00, 0x00, 0x00, //0x000005b8 jmp          LBB0_71
+	//0x000005bd LBB0_70
+	0x4f, 0x8d, 0x4c, 0x21, 0x05, //0x000005bd leaq         $5(%r9,%r12), %r9
+	0x4d, 0x29, 0xe5, //0x000005c2 subq         %r12, %r13
+	0x49, 0x83, 0xc5, 0xfb, //0x000005c5 addq         $-5, %r13
+	0x4d, 0x89, 0xee, //0x000005c9 movq         %r13, %r14
+	//0x000005cc LBB0_71
+	0xf6, 0x45, 0xb8, 0x02, //0x000005cc testb        $2, $-72(%rbp)
+	0x0f, 0x85, 0x23, 0x00, 0x00, 0x00, //0x000005d0 jne          LBB0_75
+	0xe9, 0xfb, 0x02, 0x00, 0x00, //0x000005d6 jmp          LBB0_116
+	//0x000005db LBB0_72
+	0xf6, 0x45, 0xb8, 0x02, //0x000005db testb        $2, $-72(%rbp)
+	0x0f, 0x85, 0x0f, 0x00, 0x00, 0x00, //0x000005df jne          LBB0_74
+	0xe9, 0x7d, 0x01, 0x00, 0x00, //0x000005e5 jmp          LBB0_94
+	//0x000005ea LBB0_73
+	0xf6, 0x45, 0xb8, 0x02, //0x000005ea testb        $2, $-72(%rbp)
+	0x0f, 0x84, 0xef, 0x02, 0x00, 0x00, //0x000005ee je           LBB0_117
+	//0x000005f4 LBB0_74
+	0x4f, 0x8d, 0x4c, 0x21, 0x04, //0x000005f4 leaq         $4(%r9,%r12), %r9
+	//0x000005f9 LBB0_75
+	0x66, 0xc7, 0x00, 0xef, 0xbf, //0x000005f9 movw         $-16401, (%rax)
+	0xc6, 0x40, 0x02, 0xbd, //0x000005fe movb         $-67, $2(%rax)
+	0xe9, 0x14, 0xff, 0xff, 0xff, //0x00000602 jmp          LBB0_55
+	//0x00000607 LBB0_76
+	0x4f, 0x8d, 0x4c, 0x21, 0x0a, //0x00000607 leaq         $10(%r9,%r12), %r9
+	0x4d, 0x29, 0xe5, //0x0000060c subq         %r12, %r13
+	0x49, 0x83, 0xc5, 0xf6, //0x0000060f addq         $-10, %r13
+	0xe9, 0x0c, 0x00, 0x00, 0x00, //0x00000613 jmp          LBB0_78
+	//0x00000618 LBB0_77
+	0x4f, 0x8d, 0x4c, 0x21, 0x0b, //0x00000618 leaq         $11(%r9,%r12), %r9
+	0x4d, 0x29, 0xe5, //0x0000061d subq         %r12, %r13
+	0x49, 0x83, 0xc5, 0xf5, //0x00000620 addq         $-11, %r13
+	//0x00000624 LBB0_78
+	0x41, 0xc1, 0xe7, 0x0a, //0x00000624 shll         $10, %r15d
+	0x41, 0x8d, 0x8c, 0x1f, 0x00, 0x24, 0xa0, 0xfc, //0x00000628 leal         $-56613888(%r15,%rbx), %ecx
+	0x81, 0xf9, 0x00, 0x00, 0x11, 0x00, //0x00000630 cmpl         $1114112, %ecx
+	0x0f, 0x82, 0x1c, 0x00, 0x00, 0x00, //0x00000636 jb           LBB0_81
+	0xf6, 0x45, 0xb8, 0x02, //0x0000063c testb        $2, $-72(%rbp)
+	0x0f, 0x84, 0x4d, 0x02, 0x00, 0x00, //0x00000640 je           LBB0_111
+	0x66, 0xc7, 0x00, 0xef, 0xbf, //0x00000646 movw         $-16401, (%rax)
+	0xc6, 0x40, 0x02, 0xbd, //0x0000064b movb         $-67, $2(%rax)
+	0x48, 0x83, 0xc0, 0x03, //0x0000064f addq         $3, %rax
+	0xe9, 0xca, 0xfe, 0xff, 0xff, //0x00000653 jmp          LBB0_57
+	//0x00000658 LBB0_81
+	0x89, 0xce, //0x00000658 movl         %ecx, %esi
+	0xc1, 0xee, 0x12, //0x0000065a shrl         $18, %esi
+	0x40, 0x80, 0xce, 0xf0, //0x0000065d orb          $-16, %sil
+	0x40, 0x88, 0x30, //0x00000661 movb         %sil, (%rax)
+	0x89, 0xce, //0x00000664 movl         %ecx, %esi
+	0xc1, 0xee, 0x0c, //0x00000666 shrl         $12, %esi
+	0x40, 0x80, 0xe6, 0x3f, //0x00000669 andb         $63, %sil
+	0x40, 0x80, 0xce, 0x80, //0x0000066d orb          $-128, %sil
+	0x40, 0x88, 0x70, 0x01, //0x00000671 movb         %sil, $1(%rax)
+	0x89, 0xce, //0x00000675 movl         %ecx, %esi
+	0xc1, 0xee, 0x06, //0x00000677 shrl         $6, %esi
+	0x40, 0x80, 0xe6, 0x3f, //0x0000067a andb         $63, %sil
+	0x40, 0x80, 0xce, 0x80, //0x0000067e orb          $-128, %sil
+	0x40, 0x88, 0x70, 0x02, //0x00000682 movb         %sil, $2(%rax)
+	0x80, 0xe1, 0x3f, //0x00000686 andb         $63, %cl
+	0x80, 0xc9, 0x80, //0x00000689 orb          $-128, %cl
+	0x88, 0x48, 0x03, //0x0000068c movb         %cl, $3(%rax)
+	0x48, 0x83, 0xc0, 0x04, //0x0000068f addq         $4, %rax
+	0xe9, 0x8a, 0xfe, 0xff, 0xff, //0x00000693 jmp          LBB0_57
+	//0x00000698 LBB0_82
+	0x45, 0x31, 0xed, //0x00000698 xorl         %r13d, %r13d
+	0x48, 0x89, 0xd0, //0x0000069b movq         %rdx, %rax
+	//0x0000069e LBB0_83
+	0x4c, 0x01, 0xe8, //0x0000069e addq         %r13, %rax
+	0x48, 0x29, 0xd0, //0x000006a1 subq         %rdx, %rax
+	//0x000006a4 LBB0_84
+	0x48, 0x83, 0xc4, 0x28, //0x000006a4 addq         $40, %rsp
+	0x5b, //0x000006a8 popq         %rbx
+	0x41, 0x5c, //0x000006a9 popq         %r12
+	0x41, 0x5d, //0x000006ab popq         %r13
+	0x41, 0x5e, //0x000006ad popq         %r14
+	0x41, 0x5f, //0x000006af popq         %r15
+	0x5d, //0x000006b1 popq         %rbp
+	0xc3, //0x000006b2 retq         
+	//0x000006b3 LBB0_85
+	0x4c, 0x89, 0xca, //0x000006b3 movq         %r9, %rdx
+	0x48, 0x29, 0xfa, //0x000006b6 subq         %rdi, %rdx
+	0x48, 0x8b, 0x7d, 0xc8, //0x000006b9 movq         $-56(%rbp), %rdi
+	0x48, 0x89, 0x17, //0x000006bd movq         %rdx, (%rdi)
+	0x41, 0x8a, 0x09, //0x000006c0 movb         (%r9), %cl
+	0x8d, 0x71, 0xd0, //0x000006c3 leal         $-48(%rcx), %esi
+	0x48, 0xc7, 0xc0, 0xfe, 0xff, 0xff, 0xff, //0x000006c6 movq         $-2, %rax
+	0x40, 0x80, 0xfe, 0x0a, //0x000006cd cmpb         $10, %sil
+	0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x000006d1 jb           LBB0_87
+	0x80, 0xe1, 0xdf, //0x000006d7 andb         $-33, %cl
+	0x80, 0xc1, 0xbf, //0x000006da addb         $-65, %cl
+	0x80, 0xf9, 0x05, //0x000006dd cmpb         $5, %cl
+	0x0f, 0x87, 0xbe, 0xff, 0xff, 0xff, //0x000006e0 ja           LBB0_84
+	//0x000006e6 LBB0_87
+	0x48, 0x8d, 0x4a, 0x01, //0x000006e6 leaq         $1(%rdx), %rcx
+	0x48, 0x89, 0x0f, //0x000006ea movq         %rcx, (%rdi)
+	0x41, 0x8a, 0x49, 0x01, //0x000006ed movb         $1(%r9), %cl
+	0x8d, 0x71, 0xd0, //0x000006f1 leal         $-48(%rcx), %esi
+	0x40, 0x80, 0xfe, 0x0a, //0x000006f4 cmpb         $10, %sil
+	0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x000006f8 jb           LBB0_89
+	0x80, 0xe1, 0xdf, //0x000006fe andb         $-33, %cl
+	0x80, 0xc1, 0xbf, //0x00000701 addb         $-65, %cl
+	0x80, 0xf9, 0x05, //0x00000704 cmpb         $5, %cl
+	0x0f, 0x87, 0x97, 0xff, 0xff, 0xff, //0x00000707 ja           LBB0_84
+	//0x0000070d LBB0_89
+	0x48, 0x8d, 0x4a, 0x02, //0x0000070d leaq         $2(%rdx), %rcx
+	0x48, 0x89, 0x0f, //0x00000711 movq         %rcx, (%rdi)
+	0x41, 0x8a, 0x49, 0x02, //0x00000714 movb         $2(%r9), %cl
+	0x8d, 0x71, 0xd0, //0x00000718 leal         $-48(%rcx), %esi
+	0x40, 0x80, 0xfe, 0x0a, //0x0000071b cmpb         $10, %sil
+	0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x0000071f jb           LBB0_91
+	0x80, 0xe1, 0xdf, //0x00000725 andb         $-33, %cl
+	0x80, 0xc1, 0xbf, //0x00000728 addb         $-65, %cl
+	0x80, 0xf9, 0x05, //0x0000072b cmpb         $5, %cl
+	0x0f, 0x87, 0x70, 0xff, 0xff, 0xff, //0x0000072e ja           LBB0_84
+	//0x00000734 LBB0_91
+	0x48, 0x8d, 0x4a, 0x03, //0x00000734 leaq         $3(%rdx), %rcx
+	0x48, 0x89, 0x0f, //0x00000738 movq         %rcx, (%rdi)
+	0x41, 0x8a, 0x49, 0x03, //0x0000073b movb         $3(%r9), %cl
+	0x8d, 0x71, 0xd0, //0x0000073f leal         $-48(%rcx), %esi
+	0x40, 0x80, 0xfe, 0x0a, //0x00000742 cmpb         $10, %sil
+	0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x00000746 jb           LBB0_93
+	0x80, 0xe1, 0xdf, //0x0000074c andb         $-33, %cl
+	0x80, 0xc1, 0xbf, //0x0000074f addb         $-65, %cl
+	0x80, 0xf9, 0x05, //0x00000752 cmpb         $5, %cl
+	0x0f, 0x87, 0x49, 0xff, 0xff, 0xff, //0x00000755 ja           LBB0_84
+	//0x0000075b LBB0_93
+	0x48, 0x83, 0xc2, 0x04, //0x0000075b addq         $4, %rdx
+	0x48, 0x89, 0x17, //0x0000075f movq         %rdx, (%rdi)
+	0xe9, 0x3d, 0xff, 0xff, 0xff, //0x00000762 jmp          LBB0_84
+	//0x00000767 LBB0_94
+	0x48, 0x8b, 0x45, 0xc8, //0x00000767 movq         $-56(%rbp), %rax
+	0x4c, 0x89, 0x18, //0x0000076b movq         %r11, (%rax)
+	0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x0000076e movq         $-1, %rax
+	0xe9, 0x2a, 0xff, 0xff, 0xff, //0x00000775 jmp          LBB0_84
+	//0x0000077a LBB0_95
+	0x48, 0xf7, 0xd7, //0x0000077a notq         %rdi
+	0x49, 0x01, 0xf9, //0x0000077d addq         %rdi, %r9
+	0x48, 0x8b, 0x45, 0xc8, //0x00000780 movq         $-56(%rbp), %rax
+	0x4c, 0x89, 0x08, //0x00000784 movq         %r9, (%rax)
+	0x48, 0xc7, 0xc0, 0xfd, 0xff, 0xff, 0xff, //0x00000787 movq         $-3, %rax
+	0xe9, 0x11, 0xff, 0xff, 0xff, //0x0000078e jmp          LBB0_84
+	//0x00000793 LBB0_96
+	0x45, 0x31, 0xed, //0x00000793 xorl         %r13d, %r13d
+	0xe9, 0x03, 0xff, 0xff, 0xff, //0x00000796 jmp          LBB0_83
+	//0x0000079b LBB0_97
+	0x48, 0xf7, 0xd7, //0x0000079b notq         %rdi
+	0x49, 0x01, 0xf9, //0x0000079e addq         %rdi, %r9
+	0xe9, 0xda, 0x00, 0x00, 0x00, //0x000007a1 jmp          LBB0_110
+	//0x000007a6 LBB0_98
+	0x4b, 0x8d, 0x74, 0x21, 0x04, //0x000007a6 leaq         $4(%r9,%r12), %rsi
+	0xe9, 0x05, 0x00, 0x00, 0x00, //0x000007ab jmp          LBB0_100
+	//0x000007b0 LBB0_99
+	0x4b, 0x8d, 0x74, 0x21, 0x05, //0x000007b0 leaq         $5(%r9,%r12), %rsi
+	//0x000007b5 LBB0_100
+	0x48, 0x89, 0xf2, //0x000007b5 movq         %rsi, %rdx
+	0x48, 0x29, 0xfa, //0x000007b8 subq         %rdi, %rdx
+	0x48, 0x83, 0xc2, 0x02, //0x000007bb addq         $2, %rdx
+	0x48, 0x8b, 0x45, 0xc8, //0x000007bf movq         $-56(%rbp), %rax
+	0x48, 0x89, 0x10, //0x000007c3 movq         %rdx, (%rax)
+	0x8a, 0x4e, 0x02, //0x000007c6 movb         $2(%rsi), %cl
+	0x8d, 0x79, 0xd0, //0x000007c9 leal         $-48(%rcx), %edi
+	0x48, 0xc7, 0xc0, 0xfe, 0xff, 0xff, 0xff, //0x000007cc movq         $-2, %rax
+	0x40, 0x80, 0xff, 0x0a, //0x000007d3 cmpb         $10, %dil
+	0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x000007d7 jb           LBB0_102
+	0x80, 0xe1, 0xdf, //0x000007dd andb         $-33, %cl
+	0x80, 0xc1, 0xbf, //0x000007e0 addb         $-65, %cl
+	0x80, 0xf9, 0x05, //0x000007e3 cmpb         $5, %cl
+	0x0f, 0x87, 0xb8, 0xfe, 0xff, 0xff, //0x000007e6 ja           LBB0_84
+	//0x000007ec LBB0_102
+	0x48, 0x8d, 0x4a, 0x01, //0x000007ec leaq         $1(%rdx), %rcx
+	0x48, 0x8b, 0x7d, 0xc8, //0x000007f0 movq         $-56(%rbp), %rdi
+	0x48, 0x89, 0x0f, //0x000007f4 movq         %rcx, (%rdi)
+	0x8a, 0x4e, 0x03, //0x000007f7 movb         $3(%rsi), %cl
+	0x8d, 0x79, 0xd0, //0x000007fa leal         $-48(%rcx), %edi
+	0x40, 0x80, 0xff, 0x0a, //0x000007fd cmpb         $10, %dil
+	0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x00000801 jb           LBB0_104
+	0x80, 0xe1, 0xdf, //0x00000807 andb         $-33, %cl
+	0x80, 0xc1, 0xbf, //0x0000080a addb         $-65, %cl
+	0x80, 0xf9, 0x05, //0x0000080d cmpb         $5, %cl
+	0x0f, 0x87, 0x8e, 0xfe, 0xff, 0xff, //0x00000810 ja           LBB0_84
+	//0x00000816 LBB0_104
+	0x48, 0x8d, 0x4a, 0x02, //0x00000816 leaq         $2(%rdx), %rcx
+	0x48, 0x8b, 0x7d, 0xc8, //0x0000081a movq         $-56(%rbp), %rdi
+	0x48, 0x89, 0x0f, //0x0000081e movq         %rcx, (%rdi)
+	0x8a, 0x4e, 0x04, //0x00000821 movb         $4(%rsi), %cl
+	0x8d, 0x79, 0xd0, //0x00000824 leal         $-48(%rcx), %edi
+	0x40, 0x80, 0xff, 0x0a, //0x00000827 cmpb         $10, %dil
+	0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x0000082b jb           LBB0_106
+	0x80, 0xe1, 0xdf, //0x00000831 andb         $-33, %cl
+	0x80, 0xc1, 0xbf, //0x00000834 addb         $-65, %cl
+	0x80, 0xf9, 0x05, //0x00000837 cmpb         $5, %cl
+	0x0f, 0x87, 0x64, 0xfe, 0xff, 0xff, //0x0000083a ja           LBB0_84
+	//0x00000840 LBB0_106
+	0x48, 0x8d, 0x4a, 0x03, //0x00000840 leaq         $3(%rdx), %rcx
+	0x48, 0x8b, 0x7d, 0xc8, //0x00000844 movq         $-56(%rbp), %rdi
+	0x48, 0x89, 0x0f, //0x00000848 movq         %rcx, (%rdi)
+	0x8a, 0x4e, 0x05, //0x0000084b movb         $5(%rsi), %cl
+	0x8d, 0x71, 0xd0, //0x0000084e leal         $-48(%rcx), %esi
+	0x40, 0x80, 0xfe, 0x0a, //0x00000851 cmpb         $10, %sil
+	0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x00000855 jb           LBB0_108
+	0x80, 0xe1, 0xdf, //0x0000085b andb         $-33, %cl
+	0x80, 0xc1, 0xbf, //0x0000085e addb         $-65, %cl
+	0x80, 0xf9, 0x05, //0x00000861 cmpb         $5, %cl
+	0x0f, 0x87, 0x3a, 0xfe, 0xff, 0xff, //0x00000864 ja           LBB0_84
+	//0x0000086a LBB0_108
+	0x48, 0x83, 0xc2, 0x04, //0x0000086a addq         $4, %rdx
+	0x48, 0x8b, 0x4d, 0xc8, //0x0000086e movq         $-56(%rbp), %rcx
+	0x48, 0x89, 0x11, //0x00000872 movq         %rdx, (%rcx)
+	0xe9, 0x2a, 0xfe, 0xff, 0xff, //0x00000875 jmp          LBB0_84
+	//0x0000087a LBB0_109
+	0x49, 0x29, 0xf9, //0x0000087a subq         %rdi, %r9
+	0x49, 0xff, 0xc1, //0x0000087d incq         %r9
+	//0x00000880 LBB0_110
+	0x48, 0x8b, 0x45, 0xc8, //0x00000880 movq         $-56(%rbp), %rax
+	0x4c, 0x89, 0x08, //0x00000884 movq         %r9, (%rax)
+	0x48, 0xc7, 0xc0, 0xfe, 0xff, 0xff, 0xff, //0x00000887 movq         $-2, %rax
+	0xe9, 0x11, 0xfe, 0xff, 0xff, //0x0000088e jmp          LBB0_84
+	//0x00000893 LBB0_111
+	0x49, 0x29, 0xf9, //0x00000893 subq         %rdi, %r9
+	0x49, 0x83, 0xc1, 0xfc, //0x00000896 addq         $-4, %r9
+	//0x0000089a LBB0_112
+	0x48, 0x8b, 0x45, 0xc8, //0x0000089a movq         $-56(%rbp), %rax
+	0x4c, 0x89, 0x08, //0x0000089e movq         %r9, (%rax)
+	0x48, 0xc7, 0xc0, 0xfc, 0xff, 0xff, 0xff, //0x000008a1 movq         $-4, %rax
+	0xe9, 0xf7, 0xfd, 0xff, 0xff, //0x000008a8 jmp          LBB0_84
+	//0x000008ad LBB0_113
+	0x4b, 0x8d, 0x44, 0x21, 0x0a, //0x000008ad leaq         $10(%r9,%r12), %rax
+	0xe9, 0x05, 0x00, 0x00, 0x00, //0x000008b2 jmp          LBB0_115
+	//0x000008b7 LBB0_114
+	0x4b, 0x8d, 0x44, 0x21, 0x0b, //0x000008b7 leaq         $11(%r9,%r12), %rax
+	//0x000008bc LBB0_115
+	0x48, 0x29, 0xf8, //0x000008bc subq         %rdi, %rax
+	0x48, 0x83, 0xc0, 0xfc, //0x000008bf addq         $-4, %rax
+	0x48, 0x8b, 0x4d, 0xc8, //0x000008c3 movq         $-56(%rbp), %rcx
+	0x48, 0x89, 0x01, //0x000008c7 movq         %rax, (%rcx)
+	0x48, 0xc7, 0xc0, 0xfc, 0xff, 0xff, 0xff, //0x000008ca movq         $-4, %rax
+	0xe9, 0xce, 0xfd, 0xff, 0xff, //0x000008d1 jmp          LBB0_84
+	//0x000008d6 LBB0_116
+	0x49, 0x8d, 0x44, 0x3a, 0x04, //0x000008d6 leaq         $4(%r10,%rdi), %rax
+	0x49, 0x29, 0xc1, //0x000008db subq         %rax, %r9
+	0xe9, 0xb7, 0xff, 0xff, 0xff, //0x000008de jmp          LBB0_112
+	//0x000008e3 LBB0_117
+	0x4d, 0x01, 0xe1, //0x000008e3 addq         %r12, %r9
+	0x49, 0x29, 0xf9, //0x000008e6 subq         %rdi, %r9
+	0xe9, 0xac, 0xff, 0xff, 0xff, //0x000008e9 jmp          LBB0_112
+	0x00, 0x00, //0x000008ee .p2align 4, 0x00
+	//0x000008f0 __UnquoteTab
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000008f0 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000900 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2f, //0x00000910 QUAD $0x0000000000220000; QUAD $0x2f00000000000000  // .ascii 16, '\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000920 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000930 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, //0x00000940 QUAD $0x0000000000000000; QUAD $0x0000005c00000000  // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00'
+	0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, //0x00000950 QUAD $0x000c000000080000; QUAD $0x000a000000000000  // .ascii 16, '\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00'
+	0x00, 0x00, 0x0d, 0x00, 0x09, 0xff, //0x00000960 LONG $0x000d0000; WORD $0xff09  // .ascii 6, '\x00\x00\r\x00\t\xff'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000966 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000976 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000986 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000996 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009a6 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009b6 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009c6 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009d6 QUAD $0x0000000000000000; QUAD $0x0000000000000000  // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000009e6 QUAD $0x0000000000000000; WORD $0x0000  // .space 10, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+}
+ 

vendor/github.com/bytedance/sonic/internal/native/avx/validate_one.go

@@ -0,0 +1,37 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_validate_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+var S_validate_one uintptr
+
+//go:nosplit
+func validate_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return F_validate_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}

vendor/github.com/bytedance/sonic/internal/native/avx/validate_one_subr.go

@@ -0,0 +1,46 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+import (
+	`github.com/bytedance/sonic/loader`
+)
+
+const (
+    _entry__validate_one = 144
+)
+
+const (
+    _stack__validate_one = 152
+)
+
+const (
+    _size__validate_one = 9524
+)
+
+var (
+    _pcsp__validate_one = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {8962, 152},
+        {8966, 48},
+        {8967, 40},
+        {8969, 32},
+        {8971, 24},
+        {8973, 16},
+        {8975, 8},
+        {8976, 0},
+        {9524, 152},
+    }
+)
+
+var _cfunc_validate_one = []loader.CFunc{
+    {"_validate_one_entry", 0,  _entry__validate_one, 0, nil},
+    {"_validate_one", _entry__validate_one, _size__validate_one, _stack__validate_one, _pcsp__validate_one},
+}

vendor/github.com/bytedance/sonic/internal/native/avx/validate_utf8.go

@@ -0,0 +1,39 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var F_validate_utf8 func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+var S_validate_utf8 uintptr
+
+//go:nosplit
+func validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) {
+    return F_validate_utf8(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
+}
+
+