diff options
Diffstat (limited to 'vendor/github.com/bytedance/sonic/internal')
48 files changed, 52323 insertions, 0 deletions
diff --git a/vendor/github.com/bytedance/sonic/internal/caching/asm.s b/vendor/github.com/bytedance/sonic/internal/caching/asm.s new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/caching/asm.s diff --git a/vendor/github.com/bytedance/sonic/internal/caching/fcache.go b/vendor/github.com/bytedance/sonic/internal/caching/fcache.go new file mode 100644 index 000000000..8cf62ff44 --- /dev/null +++ b/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 + } +} diff --git a/vendor/github.com/bytedance/sonic/internal/caching/hashing.go b/vendor/github.com/bytedance/sonic/internal/caching/hashing.go new file mode 100644 index 000000000..b8876a410 --- /dev/null +++ b/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) + } +} diff --git a/vendor/github.com/bytedance/sonic/internal/caching/pcache.go b/vendor/github.com/bytedance/sonic/internal/caching/pcache.go new file mode 100644 index 000000000..8c1224d9c --- /dev/null +++ b/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 +} diff --git a/vendor/github.com/bytedance/sonic/internal/cpu/features.go b/vendor/github.com/bytedance/sonic/internal/cpu/features.go new file mode 100644 index 000000000..f9ee3b8f3 --- /dev/null +++ b/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)) + } +} diff --git a/vendor/github.com/bytedance/sonic/internal/jit/arch_amd64.go b/vendor/github.com/bytedance/sonic/internal/jit/arch_amd64.go new file mode 100644 index 000000000..7405052d6 --- /dev/null +++ b/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, + } +} diff --git a/vendor/github.com/bytedance/sonic/internal/jit/asm.s b/vendor/github.com/bytedance/sonic/internal/jit/asm.s new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/jit/asm.s diff --git a/vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go b/vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go new file mode 100644 index 000000000..00e6009db --- /dev/null +++ b/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() +} diff --git a/vendor/github.com/bytedance/sonic/internal/jit/backend.go b/vendor/github.com/bytedance/sonic/internal/jit/backend.go new file mode 100644 index 000000000..75e180415 --- /dev/null +++ b/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 +} diff --git a/vendor/github.com/bytedance/sonic/internal/jit/runtime.go b/vendor/github.com/bytedance/sonic/internal/jit/runtime.go new file mode 100644 index 000000000..ec69d067a --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/jit/runtime.go @@ -0,0 +1,54 @@ +/* + * 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` +) + +//go:noescape +//go:linkname getitab runtime.getitab +//goland:noinspection ALL +func getitab(inter *rt.GoType, typ *rt.GoType, canfail bool) *rt.GoItab + +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(getitab(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)))) +} diff --git a/vendor/github.com/bytedance/sonic/internal/loader/asm.s b/vendor/github.com/bytedance/sonic/internal/loader/asm.s new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/loader/asm.s diff --git a/vendor/github.com/bytedance/sonic/internal/loader/funcdata.go b/vendor/github.com/bytedance/sonic/internal/loader/funcdata.go new file mode 100644 index 000000000..59a3cb349 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/loader/funcdata.go @@ -0,0 +1,124 @@ +/* + * 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 loader + +import ( + `reflect` + `sync` + `unsafe` + + `github.com/bytedance/sonic/internal/rt` +) + +//go:linkname lastmoduledatap runtime.lastmoduledatap +//goland:noinspection GoUnusedGlobalVariable +var lastmoduledatap *_ModuleData + +//go:linkname moduledataverify1 runtime.moduledataverify1 +func moduledataverify1(_ *_ModuleData) + +// PCDATA and FUNCDATA table indexes. +// +// See funcdata.h and $GROOT/src/cmd/internal/objabi/funcdata.go. +const ( + _FUNCDATA_ArgsPointerMaps = 0 + _FUNCDATA_LocalsPointerMaps = 1 +) + +type funcInfo struct { + *_Func + datap *_ModuleData +} + +//go:linkname findfunc runtime.findfunc +func findfunc(pc uintptr) funcInfo + +//go:linkname funcdata runtime.funcdata +func funcdata(f funcInfo, i uint8) unsafe.Pointer + +var ( + modLock sync.Mutex + modList []*_ModuleData +) + +var emptyByte byte + +func encodeVariant(v int) []byte { + var u int + var r []byte + + /* split every 7 bits */ + for v > 127 { + u = v & 0x7f + v = v >> 7 + r = append(r, byte(u) | 0x80) + } + + /* check for last one */ + if v == 0 { + return r + } + + /* add the last one */ + r = append(r, byte(v)) + return r +} + +func registerModule(mod *_ModuleData) { + modLock.Lock() + modList = append(modList, mod) + lastmoduledatap.next = mod + lastmoduledatap = mod + modLock.Unlock() +} + +func stackMap(f interface{}) (args uintptr, locals uintptr) { + fv := reflect.ValueOf(f) + if fv.Kind() != reflect.Func { + panic("f must be reflect.Func kind!") + } + fi := findfunc(fv.Pointer()) + return uintptr(funcdata(fi, uint8(_FUNCDATA_ArgsPointerMaps))), uintptr(funcdata(fi, uint8(_FUNCDATA_LocalsPointerMaps))) +} + +var moduleCache = struct{ + m map[*_ModuleData][]byte + l sync.Mutex +}{ + m : make(map[*_ModuleData][]byte), +} + +func cacheStackmap(argPtrs []bool, localPtrs []bool, mod *_ModuleData) (argptrs uintptr, localptrs uintptr) { + as := rt.StackMapBuilder{} + for _, b := range argPtrs { + as.AddField(b) + } + ab, _ := as.Build().MarshalBinary() + ls := rt.StackMapBuilder{} + for _, b := range localPtrs { + ls.AddField(b) + } + lb, _ := ls.Build().MarshalBinary() + cache := make([]byte, len(ab) + len(lb)) + copy(cache, ab) + copy(cache[len(ab):], lb) + moduleCache.l.Lock() + moduleCache.m[mod] = cache + moduleCache.l.Unlock() + return uintptr(rt.IndexByte(cache, 0)), uintptr(rt.IndexByte(cache, len(ab))) + +}
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go115.go b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go115.go new file mode 100644 index 000000000..b0d2d6c65 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go115.go @@ -0,0 +1,169 @@ +// +build go1.15,!go1.16 + +/* + * 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 loader + +import ( + `unsafe` + + `github.com/bytedance/sonic/internal/rt` +) + +type _Func struct { + entry uintptr // start pc + nameoff int32 // function name + args int32 // in/out args size + deferreturn uint32 // offset of start of a deferreturn call instruction from entry, if any. + pcsp int32 + pcfile int32 + pcln int32 + npcdata int32 + funcID uint8 // set for certain special runtime functions + _ [2]int8 // unused + nfuncdata uint8 // must be last + argptrs uintptr + localptrs uintptr +} + +type _FuncTab struct { + entry uintptr + funcoff uintptr +} + +type _BitVector struct { + n int32 // # of bits + bytedata *uint8 +} + +type _PtabEntry struct { + name int32 + typ int32 +} + +type _TextSection struct { + vaddr uintptr // prelinked section vaddr + length uintptr // section length + baseaddr uintptr // relocated section address +} + +type _ModuleData struct { + pclntable []byte + ftab []_FuncTab + filetab []uint32 + findfunctab *_FindFuncBucket + minpc, maxpc uintptr + text, etext uintptr + noptrdata, enoptrdata uintptr + data, edata uintptr + bss, ebss uintptr + noptrbss, enoptrbss uintptr + end, gcdata, gcbss uintptr + types, etypes uintptr + textsectmap []_TextSection + typelinks []int32 // offsets from types + itablinks []*rt.GoItab + ptab []_PtabEntry + pluginpath string + pkghashes []byte + modulename string + modulehashes []byte + hasmain uint8 // 1 if module contains the main function, 0 otherwise + gcdatamask, gcbssmask _BitVector + typemap map[int32]*rt.GoType // offset to *_rtype in previous module + bad bool // module failed to load and should be ignored + next *_ModuleData +} + +type _FindFuncBucket struct { + idx uint32 + subbuckets [16]byte +} + +var findFuncTab = &_FindFuncBucket { + idx: 1, +} + +func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) { + mod := new(_ModuleData) + minpc := pc + maxpc := pc + size + + /* build the PC & line table */ + pclnt := []byte { + 0xfb, 0xff, 0xff, 0xff, // magic : 0xfffffffb + 0, // pad1 : 0 + 0, // pad2 : 0 + 1, // minLC : 1 + 4 << (^uintptr(0) >> 63), // ptrSize : 4 << (^uintptr(0) >> 63) + } + + // cache arg and local stackmap + argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod) + + /* add the function name */ + noff := len(pclnt) + pclnt = append(append(pclnt, name...), 0) + + /* add PCDATA */ + pcsp := len(pclnt) + pclnt = append(pclnt, encodeVariant((fp + 1) << 1)...) + pclnt = append(pclnt, encodeVariant(int(size))...) + + /* function entry */ + fnv := _Func { + entry : pc, + nameoff : int32(noff), + args : int32(args), + pcsp : int32(pcsp), + nfuncdata : 2, + argptrs : uintptr(argptrs), + localptrs : uintptr(localptrs), + } + + /* align the func to 8 bytes */ + if p := len(pclnt) % 8; p != 0 { + pclnt = append(pclnt, make([]byte, 8 - p)...) + } + + /* add the function descriptor */ + foff := len(pclnt) + pclnt = append(pclnt, (*(*[unsafe.Sizeof(_Func{})]byte)(unsafe.Pointer(&fnv)))[:]...) + + /* function table */ + tab := []_FuncTab { + {entry: pc, funcoff: uintptr(foff)}, + {entry: pc, funcoff: uintptr(foff)}, + {entry: maxpc}, + } + + /* module data */ + *mod = _ModuleData { + pclntable : pclnt, + ftab : tab, + findfunctab : findFuncTab, + minpc : minpc, + maxpc : maxpc, + modulename : name, + gcdata: uintptr(unsafe.Pointer(&emptyByte)), + gcbss: uintptr(unsafe.Pointer(&emptyByte)), + } + + /* verify and register the new module */ + moduledataverify1(mod) + registerModule(mod) +} diff --git a/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go116.go b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go116.go new file mode 100644 index 000000000..f01747f93 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go116.go @@ -0,0 +1,175 @@ +//go:build go1.16 && !go1.18 +// +build go1.16,!go1.18 + +/* + * 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 loader + +import ( + `unsafe` +) + +type _Func struct { + entry uintptr // start pc + nameoff int32 // function name + args int32 // in/out args size + deferreturn uint32 // offset of start of a deferreturn call instruction from entry, if any. + pcsp uint32 + pcfile uint32 + pcln uint32 + npcdata uint32 + cuOffset uint32 // runtime.cutab offset of this function's CU + funcID uint8 // set for certain special runtime functions + _ [2]byte // pad + nfuncdata uint8 // must be last + argptrs uintptr + localptrs uintptr +} + +type _FuncTab struct { + entry uintptr + funcoff uintptr +} + +type _PCHeader struct { + magic uint32 // 0xFFFFFFFA + pad1, pad2 uint8 // 0,0 + minLC uint8 // min instruction size + ptrSize uint8 // size of a ptr in bytes + nfunc int // number of functions in the module + nfiles uint // number of entries in the file tab. + funcnameOffset uintptr // offset to the funcnametab variable from _PCHeader + cuOffset uintptr // offset to the cutab variable from _PCHeader + filetabOffset uintptr // offset to the filetab variable from _PCHeader + pctabOffset uintptr // offset to the pctab varible from _PCHeader + pclnOffset uintptr // offset to the pclntab variable from _PCHeader +} + +type _BitVector struct { + n int32 // # of bits + bytedata *uint8 +} + +type _PtabEntry struct { + name int32 + typ int32 +} + +type _TextSection struct { + vaddr uintptr // prelinked section vaddr + length uintptr // section length + baseaddr uintptr // relocated section address +} + +type _ModuleData struct { + pcHeader *_PCHeader + funcnametab []byte + cutab []uint32 + filetab []byte + pctab []byte + pclntable []_Func + ftab []_FuncTab + findfunctab *_FindFuncBucket + minpc, maxpc uintptr + text, etext uintptr + noptrdata, enoptrdata uintptr + data, edata uintptr + bss, ebss uintptr + noptrbss, enoptrbss uintptr + end, gcdata, gcbss uintptr + types, etypes uintptr + textsectmap []_TextSection + typelinks []int32 + itablinks []unsafe.Pointer + ptab []_PtabEntry + pluginpath string + pkghashes []struct{} + modulename string + modulehashes []struct{} + hasmain uint8 + gcdatamask, gcbssmask _BitVector + typemap map[int32]unsafe.Pointer + bad bool + next *_ModuleData +} + +type _FindFuncBucket struct { + idx uint32 + subbuckets [16]byte +} + +var modHeader = &_PCHeader { + magic : 0xfffffffa, + minLC : 1, + nfunc : 1, + ptrSize : 4 << (^uintptr(0) >> 63), +} + +var findFuncTab = &_FindFuncBucket { + idx: 1, +} + +func makePCtab(fp int) []byte { + return append([]byte{0}, encodeVariant((fp + 1) << 1)...) +} + +func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) { + mod := new(_ModuleData) + + minpc := pc + maxpc := pc + size + + // cache arg and local stackmap + argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod) + + /* function entry */ + lnt := []_Func {{ + entry : pc, + nameoff : 1, + args : int32(args), + pcsp : 1, + nfuncdata : 2, + argptrs : uintptr(argptrs), + localptrs : uintptr(localptrs), + }} + + /* function table */ + tab := []_FuncTab { + {entry: pc}, + {entry: pc}, + {entry: maxpc}, + } + + /* module data */ + *mod = _ModuleData { + pcHeader : modHeader, + funcnametab : append(append([]byte{0}, name...), 0), + pctab : append(makePCtab(fp), encodeVariant(int(size))...), + pclntable : lnt, + ftab : tab, + findfunctab : findFuncTab, + minpc : minpc, + maxpc : maxpc, + modulename : name, + gcdata: uintptr(unsafe.Pointer(&emptyByte)), + gcbss: uintptr(unsafe.Pointer(&emptyByte)), + } + + /* verify and register the new module */ + moduledataverify1(mod) + registerModule(mod) +}
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go118.go b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go118.go new file mode 100644 index 000000000..f1d585d97 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go118.go @@ -0,0 +1,201 @@ +// +build go1.18,!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 loader + +import ( + `unsafe` + + `github.com/bytedance/sonic/internal/rt` +) + +// A FuncFlag holds bits about a function. +// This list must match the list in cmd/internal/objabi/funcid.go. +type funcFlag uint8 + +type _Func struct { + entryOff uint32 // start pc + nameoff int32 // function name + args int32 // in/out args size + deferreturn uint32 // offset of start of a deferreturn call instruction from entry, if any. + pcsp uint32 + pcfile uint32 + pcln uint32 + npcdata uint32 + cuOffset uint32 // runtime.cutab offset of this function's CU + funcID uint8 // set for certain special runtime functions + flag funcFlag + _ [1]byte // pad + nfuncdata uint8 // must be last + argptrs uint32 + localptrs uint32 +} + +type _FuncTab struct { + entry uint32 + funcoff uint32 +} + +type _PCHeader struct { + magic uint32 // 0xFFFFFFF0 + pad1, pad2 uint8 // 0,0 + minLC uint8 // min instruction size + ptrSize uint8 // size of a ptr in bytes + nfunc int // number of functions in the module + nfiles uint // number of entries in the file tab + textStart uintptr // base for function entry PC offsets in this module, equal to moduledata.text + funcnameOffset uintptr // offset to the funcnametab variable from pcHeader + cuOffset uintptr // offset to the cutab variable from pcHeader + filetabOffset uintptr // offset to the filetab variable from pcHeader + pctabOffset uintptr // offset to the pctab variable from pcHeader + pclnOffset uintptr // offset to the pclntab variable from pcHeader +} + +type _BitVector struct { + n int32 // # of bits + bytedata *uint8 +} + +type _PtabEntry struct { + name int32 + typ int32 +} + +type _TextSection struct { + vaddr uintptr // prelinked section vaddr + length uintptr // section length + baseaddr uintptr // relocated section address +} + +type _ModuleData struct { + pcHeader *_PCHeader + funcnametab []byte + cutab []uint32 + filetab []byte + pctab []byte + pclntable []byte + ftab []_FuncTab + findfunctab *_FindFuncBucket + minpc, maxpc uintptr + text, etext uintptr + noptrdata, enoptrdata uintptr + data, edata uintptr + bss, ebss uintptr + noptrbss, enoptrbss uintptr + end, gcdata, gcbss uintptr + types, etypes uintptr + rodata uintptr + gofunc uintptr + textsectmap []_TextSection + typelinks []int32 + itablinks []unsafe.Pointer + ptab []_PtabEntry + pluginpath string + pkghashes []struct{} + modulename string + modulehashes []struct{} + hasmain uint8 + gcdatamask, gcbssmask _BitVector + typemap map[int32]unsafe.Pointer + bad bool + next *_ModuleData +} + + +type _FindFuncBucket struct { + idx uint32 + subbuckets [16]byte +} + + + +func makePCtab(fp int) []byte { + return append([]byte{0}, encodeVariant((fp + 1) << 1)...) +} + +func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) { + mod := new(_ModuleData) + + minpc := pc + maxpc := pc + size + + findFuncTab := make([]_FindFuncBucket, textSize/4096 + 1) + + modHeader := &_PCHeader { + magic : 0xfffffff0, + minLC : 1, + nfunc : 1, + ptrSize : 4 << (^uintptr(0) >> 63), + textStart: minpc, + } + + // cache arg and local stackmap + argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod) + + base := argptrs + if argptrs > localptrs { + base = localptrs + } + + /* function entry */ + lnt := []_Func {{ + entryOff : 0, + nameoff : 1, + args : int32(args), + pcsp : 1, + nfuncdata : 2, + argptrs: uint32(argptrs - base), + localptrs: uint32(localptrs - base), + }} + nlnt := len(lnt)*int(unsafe.Sizeof(_Func{})) + plnt := unsafe.Pointer(&lnt[0]) + + /* function table */ + ftab := []_FuncTab { + {entry : 0, funcoff : 16}, + {entry : uint32(size)}, + } + nftab := len(ftab)*int(unsafe.Sizeof(_FuncTab{})) + pftab := unsafe.Pointer(&ftab[0]) + + pclntab := make([]byte, 0, nftab + nlnt) + pclntab = append(pclntab, rt.BytesFrom(pftab, nftab, nftab)...) + pclntab = append(pclntab, rt.BytesFrom(plnt, nlnt, nlnt)...) + + /* module data */ + *mod = _ModuleData { + pcHeader : modHeader, + funcnametab : append(append([]byte{0}, name...), 0), + pctab : append(makePCtab(fp), encodeVariant(int(size))...), + pclntable : pclntab, + ftab : ftab, + text : minpc, + etext : pc + textSize, + findfunctab : &findFuncTab[0], + minpc : minpc, + maxpc : maxpc, + modulename : name, + gcdata: uintptr(unsafe.Pointer(&emptyByte)), + gcbss: uintptr(unsafe.Pointer(&emptyByte)), + gofunc: base, + } + + /* verify and register the new module */ + moduledataverify1(mod) + registerModule(mod) +}
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go120.go b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go120.go new file mode 100644 index 000000000..c12f8a73c --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go120.go @@ -0,0 +1,201 @@ +// +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 loader + +import ( + `unsafe` + + `github.com/bytedance/sonic/internal/rt` +) + +// A FuncFlag holds bits about a function. +// This list must match the list in cmd/internal/objabi/funcid.go. +type funcFlag uint8 + +type _Func struct { + entryOff uint32 // start pc + nameoff int32 // function name + args int32 // in/out args size + deferreturn uint32 // offset of start of a deferreturn call instruction from entry, if any. + pcsp uint32 + pcfile uint32 + pcln uint32 + npcdata uint32 + cuOffset uint32 // runtime.cutab offset of this function's CU + funcID uint8 // set for certain special runtime functions + flag funcFlag + _ [1]byte // pad + nfuncdata uint8 // must be last + argptrs uint32 + localptrs uint32 +} + +type _FuncTab struct { + entry uint32 + funcoff uint32 +} + +type _PCHeader struct { + magic uint32 // 0xFFFFFFF0 + pad1, pad2 uint8 // 0,0 + minLC uint8 // min instruction size + ptrSize uint8 // size of a ptr in bytes + nfunc int // number of functions in the module + nfiles uint // number of entries in the file tab + textStart uintptr // base for function entry PC offsets in this module, equal to moduledata.text + funcnameOffset uintptr // offset to the funcnametab variable from pcHeader + cuOffset uintptr // offset to the cutab variable from pcHeader + filetabOffset uintptr // offset to the filetab variable from pcHeader + pctabOffset uintptr // offset to the pctab variable from pcHeader + pclnOffset uintptr // offset to the pclntab variable from pcHeader +} + +type _BitVector struct { + n int32 // # of bits + bytedata *uint8 +} + +type _PtabEntry struct { + name int32 + typ int32 +} + +type _TextSection struct { + vaddr uintptr // prelinked section vaddr + length uintptr // section length + baseaddr uintptr // relocated section address +} + +type _ModuleData struct { + pcHeader *_PCHeader + funcnametab []byte + cutab []uint32 + filetab []byte + pctab []byte + pclntable []byte + ftab []_FuncTab + findfunctab *_FindFuncBucket + minpc, maxpc uintptr + text, etext uintptr + noptrdata, enoptrdata uintptr + data, edata uintptr + bss, ebss uintptr + noptrbss, enoptrbss uintptr + end, gcdata, gcbss uintptr + types, etypes uintptr + rodata uintptr + gofunc uintptr + textsectmap []_TextSection + typelinks []int32 + itablinks []unsafe.Pointer + ptab []_PtabEntry + pluginpath string + pkghashes []struct{} + modulename string + modulehashes []struct{} + hasmain uint8 + gcdatamask, gcbssmask _BitVector + typemap map[int32]unsafe.Pointer + bad bool + next *_ModuleData +} + + +type _FindFuncBucket struct { + idx uint32 + subbuckets [16]byte +} + + + +func makePCtab(fp int) []byte { + return append([]byte{0}, encodeVariant((fp + 1) << 1)...) +} + +func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) { + mod := new(_ModuleData) + + minpc := pc + maxpc := pc + size + + findFuncTab := make([]_FindFuncBucket, textSize/4096 + 1) + + modHeader := &_PCHeader { + magic : 0xfffffff0, + minLC : 1, + nfunc : 1, + ptrSize : 4 << (^uintptr(0) >> 63), + textStart: minpc, + } + + // cache arg and local stackmap + argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod) + + base := argptrs + if argptrs > localptrs { + base = localptrs + } + + /* function entry */ + lnt := []_Func {{ + entryOff : 0, + nameoff : 1, + args : int32(args), + pcsp : 1, + nfuncdata : 2, + argptrs: uint32(argptrs - base), + localptrs: uint32(localptrs - base), + }} + nlnt := len(lnt)*int(unsafe.Sizeof(_Func{})) + plnt := unsafe.Pointer(&lnt[0]) + + /* function table */ + ftab := []_FuncTab { + {entry : 0, funcoff : 16}, + {entry : uint32(size)}, + } + nftab := len(ftab)*int(unsafe.Sizeof(_FuncTab{})) + pftab := unsafe.Pointer(&ftab[0]) + + pclntab := make([]byte, 0, nftab + nlnt) + pclntab = append(pclntab, rt.BytesFrom(pftab, nftab, nftab)...) + pclntab = append(pclntab, rt.BytesFrom(plnt, nlnt, nlnt)...) + + /* module data */ + *mod = _ModuleData { + pcHeader : modHeader, + funcnametab : append(append([]byte{0}, name...), 0), + pctab : append(makePCtab(fp), encodeVariant(int(size))...), + pclntable : pclntab, + ftab : ftab, + text : minpc, + etext : pc + textSize, + findfunctab : &findFuncTab[0], + minpc : minpc, + maxpc : maxpc, + modulename : name, + gcdata: uintptr(unsafe.Pointer(&emptyByte)), + gcbss: uintptr(unsafe.Pointer(&emptyByte)), + gofunc: base, + } + + /* verify and register the new module */ + moduledataverify1(mod) + registerModule(mod) +}
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/loader/loader.go b/vendor/github.com/bytedance/sonic/internal/loader/loader.go new file mode 100644 index 000000000..6446a5f07 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/loader/loader.go @@ -0,0 +1,74 @@ +//go:build darwin || linux +// +build darwin linux + +/* + * 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 loader + +import ( + `fmt` + `os` + `reflect` + `syscall` + `unsafe` +) + +const ( + _AP = syscall.MAP_ANON | syscall.MAP_PRIVATE + _RX = syscall.PROT_READ | syscall.PROT_EXEC + _RW = syscall.PROT_READ | syscall.PROT_WRITE +) + +type Loader []byte +type Function unsafe.Pointer + +func (self Loader) Load(fn string, fp int, args int, argPtrs []bool, localPtrs []bool) (f Function) { + p := os.Getpagesize() + n := (((len(self) - 1) / p) + 1) * p + + /* register the function */ + m := mmap(n) + v := fmt.Sprintf("runtime.__%s_%x", fn, m) + + registerFunction(v, m, uintptr(n), fp, args, uintptr(len(self)), argPtrs, localPtrs) + + /* reference as a slice */ + s := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader { + Data : m, + Cap : n, + Len : len(self), + })) + + /* copy the machine code, and make it executable */ + copy(s, self) + mprotect(m, n) + return Function(&m) +} + +func mmap(nb int) uintptr { + if m, _, e := syscall.RawSyscall6(syscall.SYS_MMAP, 0, uintptr(nb), _RW, _AP, 0, 0); e != 0 { + panic(e) + } else { + return m + } +} + +func mprotect(p uintptr, nb int) { + if _, _, err := syscall.RawSyscall(syscall.SYS_MPROTECT, p, uintptr(nb), _RX); err != 0 { + panic(err) + } +} diff --git a/vendor/github.com/bytedance/sonic/internal/loader/loader_windows.go b/vendor/github.com/bytedance/sonic/internal/loader/loader_windows.go new file mode 100644 index 000000000..4053ee9bb --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/loader/loader_windows.go @@ -0,0 +1,111 @@ +//go:build windows +// +build windows + +/* + * 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 loader + +import ( + `fmt` + `os` + `reflect` + `syscall` + `unsafe` +) + +const ( + MEM_COMMIT = 0x00001000 + MEM_RESERVE = 0x00002000 +) + +var ( + libKernel32 = syscall.NewLazyDLL("KERNEL32.DLL") + libKernel32_VirtualAlloc = libKernel32.NewProc("VirtualAlloc") + libKernel32_VirtualProtect = libKernel32.NewProc("VirtualProtect") +) + +type Loader []byte +type Function unsafe.Pointer + +func (self Loader) Load(fn string, fp int, args int, argPtrs []bool, localPtrs []bool) (f Function) { + p := os.Getpagesize() + n := (((len(self) - 1) / p) + 1) * p + + /* register the function */ + m := mmap(n) + v := fmt.Sprintf("runtime.__%s_%x", fn, m) + + registerFunction(v, m, uintptr(n), fp, args, uintptr(len(self)), argPtrs, localPtrs) + + /* reference as a slice */ + s := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader { + Data : m, + Cap : n, + Len : len(self), + })) + + /* copy the machine code, and make it executable */ + copy(s, self) + mprotect(m, n) + return Function(&m) +} + +func mmap(nb int) uintptr { + addr, err := winapi_VirtualAlloc(0, nb, MEM_COMMIT|MEM_RESERVE, syscall.PAGE_READWRITE) + if err != nil { + panic(err) + } + return addr +} + +func mprotect(p uintptr, nb int) (oldProtect int) { + err := winapi_VirtualProtect(p, nb, syscall.PAGE_EXECUTE_READ, &oldProtect) + if err != nil { + panic(err) + } + return +} + +// winapi_VirtualAlloc allocate memory +// Doc: https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc +func winapi_VirtualAlloc(lpAddr uintptr, dwSize int, flAllocationType int, flProtect int) (uintptr, error) { + r1, _, err := libKernel32_VirtualAlloc.Call( + lpAddr, + uintptr(dwSize), + uintptr(flAllocationType), + uintptr(flProtect), + ) + if r1 == 0 { + return 0, err + } + return r1, nil +} + +// winapi_VirtualProtect change memory protection +// Doc: https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualprotect +func winapi_VirtualProtect(lpAddr uintptr, dwSize int, flNewProtect int, lpflOldProtect *int) error { + r1, _, err := libKernel32_VirtualProtect.Call( + lpAddr, + uintptr(dwSize), + uintptr(flNewProtect), + uintptr(unsafe.Pointer(lpflOldProtect)), + ) + if r1 == 0 { + return err + } + return nil +} diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go new file mode 100644 index 000000000..8a42449b8 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go @@ -0,0 +1,135 @@ +// 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` +) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __i64toa(out *byte, val int64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __u64toa(out *byte, val uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __f64toa(out *byte, val float64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __f32toa(out *byte, val float32) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __lspace(sp unsafe.Pointer, nb int, off int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vstring(s *string, p *int, v *types.JsonState, flags uint64) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vnumber(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vsigned(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vunsigned(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_one_fast(s *string, p *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_number(s *string, p *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_one(s *string, p *int, m *types.StateMachine) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __get_by_path(s *string, p *int, path *[]interface{}) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_utf8_fast(s *string) (ret int)
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.s new file mode 100644 index 000000000..3b5304093 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.s @@ -0,0 +1,15286 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__native_entry__(SB), NOSPLIT, $0 + NO_LOCAL_POINTERS + LONG $0xf9058d48; WORD $0xffff; BYTE $0xff // leaq $-7(%rip), %rax + LONG $0x24448948; BYTE $0x08 // movq %rax, $8(%rsp) + BYTE $0xc3 // retq + WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI0_0: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + +LCPI0_1: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI0_2: + QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' + +LCPI0_3: + QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + + // .p2align 4, 0x90 +_lspace: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + LONG $0x0066840f; WORD $0x0000 // je LBB0_7, $102(%rip) + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xe183; BYTE $0x0f // andl $15, %ecx + LONG $0x005a840f; WORD $0x0000 // je LBB0_7, $90(%rip) + LONG $0x014f8d4c // leaq $1(%rdi), %r9 + LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx + QUAD $0x000100002600b849; WORD $0x0000 // movabsq $4294977024, %r8 + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB0_3: + LONG $0x0714be0f // movsbl (%rdi,%rax), %edx + WORD $0xfa83; BYTE $0x20 // cmpl $32, %edx + LONG $0x00f0870f; WORD $0x0000 // ja LBB0_22, $240(%rip) + LONG $0xd0a30f49 // btq %rdx, %r8 + LONG $0x00e6830f; WORD $0x0000 // jae LBB0_22, $230(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x000f840f; WORD $0x0000 // je LBB0_6, $15(%rip) + WORD $0x0144; BYTE $0xc8 // addl %r9d, %eax + WORD $0xe083; BYTE $0x0f // andl $15, %eax + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0xffcd850f; WORD $0xffff // jne LBB0_3, $-51(%rip) + +LBB0_6: + LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 + WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + +LBB0_7: + LONG $0x10fa8348 // cmpq $16, %rdx + LONG $0x006e820f; WORD $0x0000 // jb LBB0_13, $110(%rip) + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi + QUAD $0xffffff2b056ff9c5 // vmovdqa $-213(%rip), %xmm0 /* LCPI0_0(%rip) */ + QUAD $0xffffff330d6ff9c5 // vmovdqa $-205(%rip), %xmm1 /* LCPI0_1(%rip) */ + QUAD $0xffffff3b156ff9c5 // vmovdqa $-197(%rip), %xmm2 /* LCPI0_2(%rip) */ + QUAD $0xffffff431d6ff9c5 // vmovdqa $-189(%rip), %xmm3 /* LCPI0_3(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB0_9: + LONG $0x6f79c1c4; BYTE $0x22 // vmovdqa (%r10), %xmm4 + LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 + LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 + LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 + LONG $0xf274d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm6 + LONG $0xe374d9c5 // vpcmpeqb %xmm3, %xmm4, %xmm4 + LONG $0xe6ebd9c5 // vpor %xmm6, %xmm4, %xmm4 + LONG $0xe5ebd9c5 // vpor %xmm5, %xmm4, %xmm4 + LONG $0xc4d7f9c5 // vpmovmskb %xmm4, %eax + LONG $0xfff88366 // cmpw $-1, %ax + LONG $0x0060850f; WORD $0x0000 // jne LBB0_10, $96(%rip) + LONG $0x10c28349 // addq $16, %r10 + LONG $0xf0c28348 // addq $-16, %rdx + LONG $0xf0c68348 // addq $-16, %rsi + LONG $0x0ffa8348 // cmpq $15, %rdx + LONG $0xffbb870f; WORD $0xffff // ja LBB0_9, $-69(%rip) + +LBB0_13: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0039840f; WORD $0x0000 // je LBB0_20, $57(%rip) + LONG $0x12048d4d // leaq (%r10,%rdx), %r8 + WORD $0xc031 // xorl %eax, %eax + QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 + WORD $0x9090 // .p2align 4, 0x90 + +LBB0_15: + LONG $0x34be0f41; BYTE $0x02 // movsbl (%r10,%rax), %esi + WORD $0xfe83; BYTE $0x20 // cmpl $32, %esi + LONG $0x002e870f; WORD $0x0000 // ja LBB0_17, $46(%rip) + LONG $0xf1a30f49 // btq %rsi, %r9 + LONG $0x0024830f; WORD $0x0000 // jae LBB0_17, $36(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx + LONG $0xffdc850f; WORD $0xffff // jne LBB0_15, $-36(%rip) + WORD $0x894d; BYTE $0xc2 // movq %r8, %r10 + +LBB0_20: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + +LBB0_21: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + +LBB0_22: + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB0_10: + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0xd0f7 // notl %eax + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax + WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB0_17: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + LONG $0xffffe3e9; BYTE $0xff // jmp LBB0_21, $-29(%rip) + QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; BYTE $0x00 // .p2align 5, 0x00 + +LCPI1_0: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x00 +LCPI1_1: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x90 +_f64toa: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + LONG $0x7ef9e1c4; BYTE $0xc2 // vmovq %xmm0, %rdx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x34e8c148 // shrq $52, %rax + LONG $0x0007ff25; BYTE $0x00 // andl $2047, %eax + LONG $0x0007ff3d; BYTE $0x00 // cmpl $2047, %eax + LONG $0x0c1e840f; WORD $0x0000 // je LBB1_1, $3102(%rip) + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 + LONG $0x3fedc149 // shrq $63, %r13 + LONG $0x2f3c8d4e // leaq (%rdi,%r13), %r15 + QUAD $0x00000000550c8d48 // leaq (,%rdx,2), %rcx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x01f5840f; WORD $0x0000 // je LBB1_3, $501(%rip) + QUAD $0xffffffffffffbf48; WORD $0x000f // movabsq $4503599627370495, %rdi + WORD $0x2148; BYTE $0xfa // andq %rdi, %rdx + WORD $0xc085 // testl %eax, %eax + LONG $0xd0758948 // movq %rsi, $-48(%rbp) + LONG $0x0bea840f; WORD $0x0000 // je LBB1_5, $3050(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0x0948; BYTE $0xd7 // orq %rdx, %rdi + LONG $0xfbcdb08d; WORD $0xffff // leal $-1075(%rax), %esi + LONG $0xfc01888d; WORD $0xffff // leal $-1023(%rax), %ecx + WORD $0xf983; BYTE $0x34 // cmpl $52, %ecx + LONG $0x001d870f; WORD $0x0000 // ja LBB1_6, $29(%rip) + LONG $0x000433b9; BYTE $0x00 // movl $1075, %ecx + WORD $0xc129 // subl %eax, %ecx + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx + WORD $0xf748; BYTE $0xd3 // notq %rbx + WORD $0x8548; BYTE $0xdf // testq %rbx, %rdi + LONG $0x0421840f; WORD $0x0000 // je LBB1_11, $1057(%rip) + +LBB1_6: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + WORD $0x940f; BYTE $0xc1 // sete %cl + WORD $0xf883; BYTE $0x02 // cmpl $2, %eax + WORD $0x930f; BYTE $0xc0 // setae %al + WORD $0xc820 // andb %cl, %al + QUAD $0x00000000bd0c8d4c // leaq (,%rdi,4), %r9 + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + LONG $0xb81c8d48 // leaq (%rax,%rdi,4), %rbx + LONG $0xfec38348 // addq $-2, %rbx + LONG $0x4413ce69; WORD $0x0013 // imull $1262611, %esi, %ecx + LONG $0x01918d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rcx), %r10d + WORD $0xc084 // testb %al, %al + LONG $0xd1440f44 // cmovel %ecx, %r10d + QUAD $0x00000002bd048d4c // leaq $2(,%rdi,4), %r8 + LONG $0x16fac141 // sarl $22, %r10d + LONG $0xb1ca6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r10d, %ecx + WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx + WORD $0xf101 // addl %esi, %ecx + LONG $0x000124b8; BYTE $0x00 // movl $292, %eax + WORD $0x2944; BYTE $0xd0 // subl %r10d, %eax + LONG $0x04e0c148 // shlq $4, %rax + LONG $0x34158d48; WORD $0x00b8; BYTE $0x00 // leaq $47156(%rip), %rdx /* _pow10_ceil_sig.g(%rip) */ + LONG $0x101c8b4c // movq (%rax,%rdx), %r11 + LONG $0x10748b4c; BYTE $0x08 // movq $8(%rax,%rdx), %r14 + WORD $0xc1fe // incb %cl + WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0x00d28348 // adcq $0, %rdx + WORD $0xf631 // xorl %esi, %esi + LONG $0xfffea948; WORD $0xffff // testq $-2, %rax + LONG $0xc6950f40 // setne %sil + WORD $0x0948; BYTE $0xd6 // orq %rdx, %rsi + WORD $0xd349; BYTE $0xe1 // shlq %cl, %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0x00d18349 // adcq $0, %r9 + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xfffea948; WORD $0xffff // testq $-2, %rax + WORD $0x950f; BYTE $0xc3 // setne %bl + WORD $0x094c; BYTE $0xcb // orq %r9, %rbx + WORD $0xd349; BYTE $0xe0 // shlq %cl, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0x00d28348 // adcq $0, %rdx + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xfffea948; WORD $0xffff // testq $-2, %rax + WORD $0x950f; BYTE $0xc1 // setne %cl + WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx + WORD $0xe783; BYTE $0x01 // andl $1, %edi + WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi + WORD $0x2948; BYTE $0xf9 // subq %rdi, %rcx + LONG $0x28fb8348 // cmpq $40, %rbx + LONG $0x0043820f; WORD $0x0000 // jb LBB1_28, $67(%rip) + QUAD $0xcccccccccccdba48; WORD $0xcccc // movabsq $-3689348814741910323, %rdx + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xe2 // mulq %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0x05efc148 // shrq $5, %rdi + QUAD $0x00000000fd048d48 // leaq (,%rdi,8), %rax + LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xc0970f41 // seta %r8b + LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx + LONG $0x28c28348 // addq $40, %rdx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xca // cmpq %rcx, %rdx + WORD $0x960f; BYTE $0xc2 // setbe %dl + WORD $0x3841; BYTE $0xd0 // cmpb %dl, %r8b + LONG $0x0134840f; WORD $0x0000 // je LBB1_8, $308(%rip) + +LBB1_28: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + LONG $0x02e8c149 // shrq $2, %r8 + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + LONG $0xfce28348 // andq $-4, %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xc7970f40 // seta %dil + LONG $0x04728d48 // leaq $4(%rdx), %rsi + WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi + WORD $0x960f; BYTE $0xc0 // setbe %al + WORD $0x3040; BYTE $0xf8 // xorb %dil, %al + LONG $0x0055840f; WORD $0x0000 // je LBB1_29, $85(%rip) + LONG $0x02ca8348 // orq $2, %rdx + LONG $0x000001bf; BYTE $0x00 // movl $1, %edi + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0x000e870f; WORD $0x0000 // ja LBB1_32, $14(%rip) + WORD $0x940f; BYTE $0xc0 // sete %al + LONG $0x02e9c041 // shrb $2, %r9b + WORD $0x2041; BYTE $0xc1 // andb %al, %r9b + LONG $0xf9b60f41 // movzbl %r9b, %edi + +LBB1_32: + WORD $0x014c; BYTE $0xc7 // addq %r8, %rdi + QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 + QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x003c870f; WORD $0x0000 // ja LBB1_34, $60(%rip) + LONG $0x0000ece9; BYTE $0x00 // jmp LBB1_40, $236(%rip) + +LBB1_3: + LONG $0x3007c641 // movb $48, (%r15) + WORD $0x2941; BYTE $0xf7 // subl %esi, %r15d + WORD $0xff41; BYTE $0xc7 // incl %r15d + WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx + LONG $0x0009e1e9; BYTE $0x00 // jmp LBB1_123, $2529(%rip) + +LBB1_29: + WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx + LONG $0xffd88349 // sbbq $-1, %r8 + WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi + QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 + QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00b5860f; WORD $0x0000 // jbe LBB1_40, $181(%rip) + +LBB1_34: + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0be8c148 // shrq $11, %rax + LONG $0x00000bba; BYTE $0x00 // movl $11, %edx + LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax + LONG $0x0136820f; WORD $0x0000 // jb LBB1_49, $310(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0ce8c148 // shrq $12, %rax + LONG $0x00000cba; BYTE $0x00 // movl $12, %edx + LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax + LONG $0x011e820f; WORD $0x0000 // jb LBB1_49, $286(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0de8c148 // shrq $13, %rax + LONG $0x00000dba; BYTE $0x00 // movl $13, %edx + LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax + LONG $0x0106820f; WORD $0x0000 // jb LBB1_49, $262(%rip) + LONG $0x00000eba; BYTE $0x00 // movl $14, %edx + QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00ee820f; WORD $0x0000 // jb LBB1_49, $238(%rip) + LONG $0x00000fba; BYTE $0x00 // movl $15, %edx + QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00d6820f; WORD $0x0000 // jb LBB1_49, $214(%rip) + QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax + WORD $0xd231 // xorl %edx, %edx + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + WORD $0x920f; BYTE $0xc2 // setb %dl + WORD $0xf283; BYTE $0x11 // xorl $17, %edx + LONG $0x0000bce9; BYTE $0x00 // jmp LBB1_49, $188(%rip) + +LBB1_8: + WORD $0xd088 // movb %dl, %al + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + WORD $0xff41; BYTE $0xc2 // incl %r10d + QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 + QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0xff4b870f; WORD $0xffff // ja LBB1_34, $-181(%rip) + +LBB1_40: + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + LONG $0x0aff8348 // cmpq $10, %rdi + LONG $0x008a820f; WORD $0x0000 // jb LBB1_49, $138(%rip) + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + LONG $0x64ff8348 // cmpq $100, %rdi + LONG $0x007b820f; WORD $0x0000 // jb LBB1_49, $123(%rip) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi + LONG $0x0069820f; WORD $0x0000 // jb LBB1_49, $105(%rip) + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi + LONG $0x0057820f; WORD $0x0000 // jb LBB1_49, $87(%rip) + LONG $0x000005ba; BYTE $0x00 // movl $5, %edx + LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi + LONG $0x0045820f; WORD $0x0000 // jb LBB1_49, $69(%rip) + LONG $0x000006ba; BYTE $0x00 // movl $6, %edx + LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi + LONG $0x0033820f; WORD $0x0000 // jb LBB1_49, $51(%rip) + LONG $0x000007ba; BYTE $0x00 // movl $7, %edx + LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi + LONG $0x0021820f; WORD $0x0000 // jb LBB1_49, $33(%rip) + LONG $0x000008ba; BYTE $0x00 // movl $8, %edx + LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi + LONG $0x000f820f; WORD $0x0000 // jb LBB1_49, $15(%rip) + LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + WORD $0xda83; BYTE $0x00 // sbbl $0, %edx + +LBB1_49: + LONG $0x12348d46 // leal (%rdx,%r10), %r14d + LONG $0x12048d42 // leal (%rdx,%r10), %eax + WORD $0xc083; BYTE $0xea // addl $-22, %eax + WORD $0xf883; BYTE $0xe4 // cmpl $-28, %eax + LONG $0x00a4870f; WORD $0x0000 // ja LBB1_62, $164(%rip) + LONG $0x01678d4d // leaq $1(%r15), %r12 + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0x007c8ae8; BYTE $0x00 // callq _format_significand, $31882(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + WORD $0x294c; BYTE $0xd0 // subq %r10, %rax + WORD $0x294c; BYTE $0xe8 // subq %r13, %rax + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_51: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x30ff7b80 // cmpb $48, $-1(%rbx) + LONG $0xff5b8d48 // leaq $-1(%rbx), %rbx + LONG $0xffef840f; WORD $0xffff // je LBB1_51, $-17(%rip) + LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx + WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x00088c0f; WORD $0x0000 // jl LBB1_54, $8(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x2404c641; BYTE $0x2e // movb $46, (%r12) + +LBB1_54: + WORD $0x03c6; BYTE $0x65 // movb $101, (%rbx) + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x011d8e0f; WORD $0x0000 // jle LBB1_55, $285(%rip) + WORD $0xff41; BYTE $0xce // decl %r14d + LONG $0x2b0143c6 // movb $43, $1(%rbx) + WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0x011f820f; WORD $0x0000 // jb LBB1_59, $287(%rip) + +LBB1_58: + WORD $0xc189 // movl %eax, %ecx + LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx + LONG $0xd1af0f48 // imulq %rcx, %rdx + LONG $0x23eac148 // shrq $35, %rdx + WORD $0x0c8d; BYTE $0x12 // leal (%rdx,%rdx), %ecx + WORD $0x0c8d; BYTE $0x89 // leal (%rcx,%rcx,4), %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0xf80d8d48; WORD $0x00b3; BYTE $0x00 // leaq $46072(%rip), %rcx /* _Digits(%rip) */ + LONG $0x510cb70f // movzwl (%rcx,%rdx,2), %ecx + LONG $0x024b8966 // movw %cx, $2(%rbx) + WORD $0x300c // orb $48, %al + WORD $0x4388; BYTE $0x04 // movb %al, $4(%rbx) + LONG $0x05c38348 // addq $5, %rbx + LONG $0x0007b3e9; BYTE $0x00 // jmp LBB1_122, $1971(%rip) + +LBB1_62: + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0105880f; WORD $0x0000 // js LBB1_63, $261(%rip) + WORD $0x8945; BYTE $0xf6 // movl %r14d, %r14d + LONG $0x371c8d4b // leaq (%r15,%r14), %rbx + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x0007dae8; BYTE $0x00 // callq _format_integer, $2010(%rip) + WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax + LONG $0x0154830f; WORD $0x0000 // jae LBB1_103, $340(%rip) + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + WORD $0x014d; BYTE $0xd5 // addq %r10, %r13 + WORD $0x014d; BYTE $0xf5 // addq %r14, %r13 + WORD $0x2949; BYTE $0xc5 // subq %rax, %r13 + LONG $0x10fd8349 // cmpq $16, %r13 + LONG $0x01f1830f; WORD $0x0000 // jae LBB1_105, $497(%rip) + +LBB1_120: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + LONG $0x000372e9; BYTE $0x00 // jmp LBB1_121, $882(%rip) + +LBB1_11: + WORD $0xd348; BYTE $0xef // shrq %cl, %rdi + QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq $8589934464, %rax + LONG $0xe47f0548; WORD $0x540b // addq $1410065535, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x0130860f; WORD $0x0000 // jbe LBB1_17, $304(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0be8c148 // shrq $11, %rax + LONG $0x00000bba; BYTE $0x00 // movl $11, %edx + LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax + LONG $0x01a2820f; WORD $0x0000 // jb LBB1_27, $418(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0ce8c148 // shrq $12, %rax + LONG $0x00000cba; BYTE $0x00 // movl $12, %edx + LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax + LONG $0x018a820f; WORD $0x0000 // jb LBB1_27, $394(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0de8c148 // shrq $13, %rax + LONG $0x00000dba; BYTE $0x00 // movl $13, %edx + LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax + LONG $0x0172820f; WORD $0x0000 // jb LBB1_27, $370(%rip) + LONG $0x00000eba; BYTE $0x00 // movl $14, %edx + QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x015a820f; WORD $0x0000 // jb LBB1_27, $346(%rip) + QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x000010ba; BYTE $0x00 // movl $16, %edx + +LBB1_26: + WORD $0xda83; BYTE $0x00 // sbbl $0, %edx + LONG $0x000140e9; BYTE $0x00 // jmp LBB1_27, $320(%rip) + +LBB1_55: + LONG $0x2d0143c6 // movb $45, $1(%rbx) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x2944; BYTE $0xf0 // subl %r14d, %eax + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0xfee1830f; WORD $0xffff // jae LBB1_58, $-287(%rip) + +LBB1_59: + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x008a820f; WORD $0x0000 // jb LBB1_61, $138(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0xe50d8d48; WORD $0x00b2; BYTE $0x00 // leaq $45797(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x02438966 // movw %ax, $2(%rbx) + LONG $0x04c38348 // addq $4, %rbx + LONG $0x0006a5e9; BYTE $0x00 // jmp LBB1_122, $1701(%rip) + +LBB1_63: + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x03ca8f0f; WORD $0x0000 // jg LBB1_76, $970(%rip) + LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) + LONG $0x02c78349 // addq $2, %r15 + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x03b7890f; WORD $0x0000 // jns LBB1_76, $951(%rip) + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0xf741; BYTE $0xd0 // notl %r8d + WORD $0x2945; BYTE $0xd0 // subl %r10d, %r8d + WORD $0xc031 // xorl %eax, %eax + LONG $0x7ff88341 // cmpl $127, %r8d + LONG $0x038e820f; WORD $0x0000 // jb LBB1_74, $910(%rip) + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x214c; BYTE $0xe0 // andq %r12, %rax + LONG $0x80488d48 // leaq $-128(%rax), %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0x07eec148 // shrq $7, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8941; BYTE $0xf1 // movl %esi, %r9d + LONG $0x03e18341 // andl $3, %r9d + LONG $0x80f98148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rcx + LONG $0x0264830f; WORD $0x0000 // jae LBB1_68, $612(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x000307e9; BYTE $0x00 // jmp LBB1_70, $775(%rip) + +LBB1_103: + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x000635e9; BYTE $0x00 // jmp LBB1_122, $1589(%rip) + +LBB1_61: + WORD $0x3004 // addb $48, %al + WORD $0x4388; BYTE $0x02 // movb %al, $2(%rbx) + LONG $0x03c38348 // addq $3, %rbx + LONG $0x000627e9; BYTE $0x00 // jmp LBB1_122, $1575(%rip) + +LBB1_17: + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + LONG $0x0aff8348 // cmpq $10, %rdi + LONG $0x007b820f; WORD $0x0000 // jb LBB1_27, $123(%rip) + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + LONG $0x64ff8348 // cmpq $100, %rdi + LONG $0x006c820f; WORD $0x0000 // jb LBB1_27, $108(%rip) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi + LONG $0x005a820f; WORD $0x0000 // jb LBB1_27, $90(%rip) + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi + LONG $0x0048820f; WORD $0x0000 // jb LBB1_27, $72(%rip) + LONG $0x000005ba; BYTE $0x00 // movl $5, %edx + LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi + LONG $0x0036820f; WORD $0x0000 // jb LBB1_27, $54(%rip) + LONG $0x000006ba; BYTE $0x00 // movl $6, %edx + LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi + LONG $0x0024820f; WORD $0x0000 // jb LBB1_27, $36(%rip) + LONG $0x000007ba; BYTE $0x00 // movl $7, %edx + LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi + LONG $0x0012820f; WORD $0x0000 // jb LBB1_27, $18(%rip) + LONG $0x000008ba; BYTE $0x00 // movl $8, %edx + LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi + LONG $0x05c8830f; WORD $0x0000 // jae LBB1_25, $1480(%rip) + +LBB1_27: + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x0005d4e8; BYTE $0x00 // callq _format_integer, $1492(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + WORD $0x5d2b; BYTE $0xd0 // subl $-48(%rbp), %ebx + LONG $0x00058de9; BYTE $0x00 // jmp LBB1_123, $1421(%rip) + +LBB1_105: + LONG $0x80fd8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r13 + LONG $0x0007830f; WORD $0x0000 // jae LBB1_110, $7(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x00013ce9; BYTE $0x00 // jmp LBB1_107, $316(%rip) + +LBB1_110: + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + LONG $0x80e18348 // andq $-128, %rcx + LONG $0x80798d48 // leaq $-128(%rcx), %rdi + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0x07eec148 // shrq $7, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xf289 // movl %esi, %edx + WORD $0xe283; BYTE $0x03 // andl $3, %edx + LONG $0x80ff8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdi + LONG $0x0007830f; WORD $0x0000 // jae LBB1_112, $7(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x0000abe9; BYTE $0x00 // jmp LBB1_114, $171(%rip) + +LBB1_112: + LONG $0xfce68348 // andq $-4, %rsi + WORD $0xff31 // xorl %edi, %edi + QUAD $0xfffff8d9056ffdc5 // vmovdqa $-1831(%rip), %ymm0 /* LCPI1_0(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_113: + LONG $0x047ffec5; BYTE $0x38 // vmovdqu %ymm0, (%rax,%rdi) + LONG $0x447ffec5; WORD $0x2038 // vmovdqu %ymm0, $32(%rax,%rdi) + LONG $0x447ffec5; WORD $0x4038 // vmovdqu %ymm0, $64(%rax,%rdi) + LONG $0x447ffec5; WORD $0x6038 // vmovdqu %ymm0, $96(%rax,%rdi) + QUAD $0x00008038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $128(%rax,%rdi) + QUAD $0x0000a038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $160(%rax,%rdi) + QUAD $0x0000c038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $192(%rax,%rdi) + QUAD $0x0000e038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $224(%rax,%rdi) + QUAD $0x00010038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $256(%rax,%rdi) + QUAD $0x00012038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $288(%rax,%rdi) + QUAD $0x00014038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $320(%rax,%rdi) + QUAD $0x00016038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $352(%rax,%rdi) + QUAD $0x00018038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $384(%rax,%rdi) + QUAD $0x0001a038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $416(%rax,%rdi) + QUAD $0x0001c038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $448(%rax,%rdi) + QUAD $0x0001e038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $480(%rax,%rdi) + LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq $512, %rdi + LONG $0xfcc68348 // addq $-4, %rsi + LONG $0xff6c850f; WORD $0xffff // jne LBB1_113, $-148(%rip) + +LBB1_114: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0047840f; WORD $0x0000 // je LBB1_117, $71(%rip) + LONG $0x07348d48 // leaq (%rdi,%rax), %rsi + LONG $0x60c68348 // addq $96, %rsi + LONG $0x07e2c148 // shlq $7, %rdx + WORD $0xff31 // xorl %edi, %edi + QUAD $0xfffff81d056ffdc5 // vmovdqa $-2019(%rip), %ymm0 /* LCPI1_0(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_116: + LONG $0x447ffec5; WORD $0xa03e // vmovdqu %ymm0, $-96(%rsi,%rdi) + LONG $0x447ffec5; WORD $0xc03e // vmovdqu %ymm0, $-64(%rsi,%rdi) + LONG $0x447ffec5; WORD $0xe03e // vmovdqu %ymm0, $-32(%rsi,%rdi) + LONG $0x047ffec5; BYTE $0x3e // vmovdqu %ymm0, (%rsi,%rdi) + LONG $0x80ef8348 // subq $-128, %rdi + WORD $0x3948; BYTE $0xfa // cmpq %rdi, %rdx + LONG $0xffdc850f; WORD $0xffff // jne LBB1_116, $-36(%rip) + +LBB1_117: + WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 + LONG $0x0444840f; WORD $0x0000 // je LBB1_122, $1092(%rip) + LONG $0x70c5f641 // testb $112, %r13b + LONG $0x004d840f; WORD $0x0000 // je LBB1_119, $77(%rip) + +LBB1_107: + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + LONG $0xf0e68348 // andq $-16, %rsi + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x0148; BYTE $0xf2 // addq %rsi, %rdx + QUAD $0xfffff7e4056ff9c5 // vmovdqa $-2076(%rip), %xmm0 /* LCPI1_1(%rip) */ + LONG $0x90909090 // .p2align 4, 0x90 + +LBB1_108: + LONG $0x047ffac5; BYTE $0x08 // vmovdqu %xmm0, (%rax,%rcx) + LONG $0x10c18348 // addq $16, %rcx + WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi + LONG $0xffee850f; WORD $0xffff // jne LBB1_108, $-18(%rip) + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0x0406840f; WORD $0x0000 // je LBB1_122, $1030(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_121: + WORD $0x02c6; BYTE $0x30 // movb $48, (%rdx) + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3948; BYTE $0xda // cmpq %rbx, %rdx + LONG $0xfff1820f; WORD $0xffff // jb LBB1_121, $-15(%rip) + LONG $0x0003ede9; BYTE $0x00 // jmp LBB1_122, $1005(%rip) + +LBB1_119: + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0xfffc6ae9; BYTE $0xff // jmp LBB1_120, $-918(%rip) + +LBB1_68: + LONG $0xfce68348 // andq $-4, %rsi + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x2a1c8d4b // leaq (%r10,%r13), %rbx + LONG $0xe2c38148; WORD $0x0001; BYTE $0x00 // addq $482, %rbx + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0xfffff767056ffdc5 // vmovdqa $-2201(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_69: + QUAD $0xfffe200b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rbx,%rcx) + QUAD $0xfffe400b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rbx,%rcx) + QUAD $0xfffe600b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rbx,%rcx) + QUAD $0xfffe800b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rbx,%rcx) + QUAD $0xfffea00b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rbx,%rcx) + QUAD $0xfffec00b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rbx,%rcx) + QUAD $0xfffee00b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rbx,%rcx) + QUAD $0xffff000b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rbx,%rcx) + QUAD $0xffff200b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rbx,%rcx) + QUAD $0xffff400b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rbx,%rcx) + QUAD $0xffff600b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rbx,%rcx) + LONG $0x447ffec5; WORD $0x800b // vmovdqu %ymm0, $-128(%rbx,%rcx) + LONG $0x447ffec5; WORD $0xa00b // vmovdqu %ymm0, $-96(%rbx,%rcx) + LONG $0x447ffec5; WORD $0xc00b // vmovdqu %ymm0, $-64(%rbx,%rcx) + LONG $0x447ffec5; WORD $0xe00b // vmovdqu %ymm0, $-32(%rbx,%rcx) + LONG $0x047ffec5; BYTE $0x0b // vmovdqu %ymm0, (%rbx,%rcx) + LONG $0x00c18148; WORD $0x0002; BYTE $0x00 // addq $512, %rcx + LONG $0xfcc68348 // addq $-4, %rsi + LONG $0xff6f850f; WORD $0xffff // jne LBB1_69, $-145(%rip) + +LBB1_70: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x003c840f; WORD $0x0000 // je LBB1_73, $60(%rip) + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x62c18348 // addq $98, %rcx + LONG $0x07e1c149 // shlq $7, %r9 + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff6b5056ffdc5 // vmovdqa $-2379(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_72: + LONG $0x447ffec5; WORD $0xa031 // vmovdqu %ymm0, $-96(%rcx,%rsi) + LONG $0x447ffec5; WORD $0xc031 // vmovdqu %ymm0, $-64(%rcx,%rsi) + LONG $0x447ffec5; WORD $0xe031 // vmovdqu %ymm0, $-32(%rcx,%rsi) + LONG $0x047ffec5; BYTE $0x31 // vmovdqu %ymm0, (%rcx,%rsi) + LONG $0x80ee8348 // subq $-128, %rsi + WORD $0x3949; BYTE $0xf1 // cmpq %rsi, %r9 + LONG $0xffdc850f; WORD $0xffff // jne LBB1_72, $-36(%rip) + +LBB1_73: + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0014840f; WORD $0x0000 // je LBB1_76, $20(%rip) + +LBB1_74: + WORD $0x0144; BYTE $0xf0 // addl %r14d, %eax + WORD $0xd8f7 // negl %eax + + // .p2align 4, 0x90 +LBB1_75: + LONG $0x3007c641 // movb $48, (%r15) + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xc8ff // decl %eax + LONG $0xfff1850f; WORD $0xffff // jne LBB1_75, $-15(%rip) + +LBB1_76: + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x007706e8; BYTE $0x00 // callq _format_significand, $30470(%rip) + WORD $0xc389 // movl %eax, %ebx + WORD $0x2844; BYTE $0xfb // subb %r15b, %bl + WORD $0x2844; BYTE $0xf3 // subb %r14b, %bl + LONG $0x3e2c8d47 // leal (%r14,%r15), %r13d + WORD $0x2941; BYTE $0xc5 // subl %eax, %r13d + LONG $0xff458d45 // leal $-1(%r13), %r8d + LONG $0xfe7d8d41 // leal $-2(%r13), %edi + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_77: + WORD $0xda89 // movl %ebx, %edx + WORD $0x5a8d; BYTE $0x03 // leal $3(%rdx), %ebx + WORD $0xc7ff // incl %edi + LONG $0xff087c80; BYTE $0x30 // cmpb $48, $-1(%rax,%rcx) + LONG $0xff498d48 // leaq $-1(%rcx), %rcx + LONG $0xffea840f; WORD $0xffff // je LBB1_77, $-22(%rip) + LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x02778e0f; WORD $0x0000 // jle LBB1_122, $631(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xfe // subl %r15d, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0xc6ff // incl %esi + WORD $0x3941; BYTE $0xf6 // cmpl %esi, %r14d + LONG $0x00308d0f; WORD $0x0000 // jge LBB1_80, $48(%rip) + WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d + WORD $0x2945; BYTE $0xf1 // subl %r14d, %r9d + WORD $0x2945; BYTE $0xf9 // subl %r15d, %r9d + WORD $0xff41; BYTE $0xc1 // incl %r9d + LONG $0x093c8d49 // leaq (%r9,%rcx), %rdi + WORD $0xff85 // testl %edi, %edi + LONG $0x00e48e0f; WORD $0x0000 // jle LBB1_99, $228(%rip) + WORD $0x8941; BYTE $0xf8 // movl %edi, %r8d + LONG $0xff588d49 // leaq $-1(%r8), %rbx + LONG $0x03fb8348 // cmpq $3, %rbx + LONG $0x006c830f; WORD $0x0000 // jae LBB1_100, $108(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x000090e9; BYTE $0x00 // jmp LBB1_96, $144(%rip) + +LBB1_80: + WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d + WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x02268e0f; WORD $0x0000 // jle LBB1_122, $550(%rip) + WORD $0x0145; BYTE $0xfe // addl %r15d, %r14d + WORD $0x2941; BYTE $0xc6 // subl %eax, %r14d + LONG $0xfec68341 // addl $-2, %r14d + WORD $0x2949; BYTE $0xce // subq %rcx, %r14 + WORD $0xd231 // xorl %edx, %edx + LONG $0x7ffe8341 // cmpl $127, %r14d + LONG $0x01fc820f; WORD $0x0000 // jb LBB1_91, $508(%rip) + LONG $0xfec58341 // addl $-2, %r13d + WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 + WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x214d; BYTE $0xc4 // andq %r8, %r12 + WORD $0x8941; BYTE $0xf9 // movl %edi, %r9d + WORD $0xff49; BYTE $0xc1 // incq %r9 + LONG $0x80e18349 // andq $-128, %r9 + LONG $0x24548d49; BYTE $0x80 // leaq $-128(%r12), %rdx + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + LONG $0x07eac149 // shrq $7, %r10 + WORD $0xff49; BYTE $0xc2 // incq %r10 + LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdx + LONG $0x0083830f; WORD $0x0000 // jae LBB1_84, $131(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x000138e9; BYTE $0x00 // jmp LBB1_86, $312(%rip) + +LBB1_100: + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + LONG $0xfce18341 // andl $-4, %r9d + WORD $0xf749; BYTE $0xd9 // negq %r9 + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_101: + LONG $0x183c8d48 // leaq (%rax,%rbx), %rdi + LONG $0xfd39748b // movl $-3(%rcx,%rdi), %esi + LONG $0xfe397489 // movl %esi, $-2(%rcx,%rdi) + LONG $0xfcc38348 // addq $-4, %rbx + WORD $0x3949; BYTE $0xd9 // cmpq %rbx, %r9 + LONG $0xffe7850f; WORD $0xffff // jne LBB1_101, $-25(%rip) + WORD $0xf748; BYTE $0xdb // negq %rbx + +LBB1_96: + LONG $0x03c0f641 // testb $3, %r8b + LONG $0x0032840f; WORD $0x0000 // je LBB1_99, $50(%rip) + LONG $0xc2b60f44 // movzbl %dl, %r8d + LONG $0x03e08341 // andl $3, %r8d + WORD $0xf749; BYTE $0xd8 // negq %r8 + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x2948; BYTE $0xde // subq %rbx, %rsi + WORD $0xff31 // xorl %edi, %edi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_98: + LONG $0x3e1c8d48 // leaq (%rsi,%rdi), %rbx + LONG $0x1914b60f // movzbl (%rcx,%rbx), %edx + LONG $0x01195488 // movb %dl, $1(%rcx,%rbx) + WORD $0xff48; BYTE $0xcf // decq %rdi + WORD $0x3949; BYTE $0xf8 // cmpq %rdi, %r8 + LONG $0xffe8850f; WORD $0xffff // jne LBB1_98, $-24(%rip) + +LBB1_99: + WORD $0x8944; BYTE $0xf2 // movl %r14d, %edx + LONG $0x1704c641; BYTE $0x2e // movb $46, (%r15,%rdx) + LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx + LONG $0x02c38348 // addq $2, %rbx + LONG $0x000154e9; BYTE $0x00 // jmp LBB1_122, $340(%rip) + +LBB1_84: + WORD $0x8944; BYTE $0xeb // movl %r13d, %ebx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x80e38348 // andq $-128, %rbx + LONG $0x80c38348 // addq $-128, %rbx + LONG $0x07ebc148 // shrq $7, %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfce38348 // andq $-4, %rbx + WORD $0xff31 // xorl %edi, %edi + QUAD $0xfffff4d0056ffdc5 // vmovdqa $-2864(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_85: + LONG $0x38148d48 // leaq (%rax,%rdi), %rdx + LONG $0x447ffec5; WORD $0x0111 // vmovdqu %ymm0, $1(%rcx,%rdx) + LONG $0x447ffec5; WORD $0x2111 // vmovdqu %ymm0, $33(%rcx,%rdx) + LONG $0x447ffec5; WORD $0x4111 // vmovdqu %ymm0, $65(%rcx,%rdx) + LONG $0x447ffec5; WORD $0x6111 // vmovdqu %ymm0, $97(%rcx,%rdx) + QUAD $0x00008111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $129(%rcx,%rdx) + QUAD $0x0000a111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $161(%rcx,%rdx) + QUAD $0x0000c111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $193(%rcx,%rdx) + QUAD $0x0000e111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $225(%rcx,%rdx) + QUAD $0x00010111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $257(%rcx,%rdx) + QUAD $0x00012111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $289(%rcx,%rdx) + QUAD $0x00014111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $321(%rcx,%rdx) + QUAD $0x00016111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $353(%rcx,%rdx) + QUAD $0x00018111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $385(%rcx,%rdx) + QUAD $0x0001a111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $417(%rcx,%rdx) + QUAD $0x0001c111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $449(%rcx,%rdx) + QUAD $0x0001e111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $481(%rcx,%rdx) + LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq $512, %rdi + LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xff67850f; WORD $0xffff // jne LBB1_85, $-153(%rip) + +LBB1_86: + WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 + LONG $0x03c2f641 // testb $3, %r10b + LONG $0x0059840f; WORD $0x0000 // je LBB1_89, $89(%rip) + WORD $0xff41; BYTE $0xc5 // incl %r13d + LONG $0x80e58141; WORD $0x0001; BYTE $0x00 // andl $384, %r13d + LONG $0x80c58341 // addl $-128, %r13d + LONG $0x07edc141 // shrl $7, %r13d + WORD $0xfe41; BYTE $0xc5 // incb %r13b + LONG $0xd5b60f41 // movzbl %r13b, %edx + WORD $0xe283; BYTE $0x03 // andl $3, %edx + LONG $0x07e2c148 // shlq $7, %rdx + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + LONG $0x61c08348 // addq $97, %rax + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff3f9056ffdc5 // vmovdqa $-3079(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_88: + LONG $0x303c8d48 // leaq (%rax,%rsi), %rdi + LONG $0x447ffec5; WORD $0xa039 // vmovdqu %ymm0, $-96(%rcx,%rdi) + LONG $0x447ffec5; WORD $0xc039 // vmovdqu %ymm0, $-64(%rcx,%rdi) + LONG $0x447ffec5; WORD $0xe039 // vmovdqu %ymm0, $-32(%rcx,%rdi) + LONG $0x047ffec5; BYTE $0x39 // vmovdqu %ymm0, (%rcx,%rdi) + LONG $0x80ee8348 // subq $-128, %rsi + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0xffd8850f; WORD $0xffff // jne LBB1_88, $-40(%rip) + +LBB1_89: + LONG $0x091c8d4a // leaq (%rcx,%r9), %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x394d; BYTE $0xe0 // cmpq %r12, %r8 + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x001e840f; WORD $0x0000 // je LBB1_122, $30(%rip) + WORD $0x8944; BYTE $0xe2 // movl %r12d, %edx + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB1_91: + WORD $0x03c6; BYTE $0x30 // movb $48, (%rbx) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xc2ff // incl %edx + WORD $0x3944; BYTE $0xda // cmpl %r11d, %edx + LONG $0xffef8c0f; WORD $0xffff // jl LBB1_91, $-17(%rip) + +LBB1_122: + WORD $0x2944; BYTE $0xd3 // subl %r10d, %ebx + +LBB1_123: + WORD $0xd889 // movl %ebx, %eax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB1_1: + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xffffe5e9; BYTE $0xff // jmp LBB1_123, $-27(%rip) + +LBB1_5: + LONG $0xfffbcebe; BYTE $0xff // movl $-1074, %esi + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0xfff441e9; BYTE $0xff // jmp LBB1_6, $-3007(%rip) + +LBB1_25: + LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + LONG $0xfff8dfe9; BYTE $0xff // jmp LBB1_26, $-1825(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_format_integer: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x20e8c148 // shrq $32, %rax + LONG $0x0016850f; WORD $0x0000 // jne LBB2_2, $22(%rip) + WORD $0x894d; BYTE $0xc3 // movq %r8, %r11 + LONG $0x2710ff81; WORD $0x0000 // cmpl $10000, %edi + LONG $0x00c3830f; WORD $0x0000 // jae LBB2_5, $195(%rip) + +LBB2_4: + WORD $0xfa89 // movl %edi, %edx + LONG $0x00011ae9; BYTE $0x00 // jmp LBB2_7, $282(%rip) + +LBB2_2: + QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0x1f00ca69; WORD $0xfa0a // imull $-100000000, %edx, %ecx + WORD $0xf901 // addl %edi, %ecx + LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xc1af0f49 // imulq %r9, %rax + LONG $0x2de8c148 // shrq $45, %rax + LONG $0x2710f869; WORD $0x0000 // imull $10000, %eax, %edi + WORD $0xf929 // subl %edi, %ecx + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xf9af0f49 // imulq %r9, %rdi + LONG $0x2defc148 // shrq $45, %rdi + LONG $0x2710ff69; WORD $0x0000 // imull $10000, %edi, %edi + WORD $0xf829 // subl %edi, %eax + WORD $0xb70f; BYTE $0xf9 // movzwl %cx, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull $5243, %edi, %r9d + LONG $0x11e9c141 // shrl $17, %r9d + LONG $0x64f96b41 // imull $100, %r9d, %edi + WORD $0xf929 // subl %edi, %ecx + LONG $0xd1b70f44 // movzwl %cx, %r10d + WORD $0xb70f; BYTE $0xf8 // movzwl %ax, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x147bff69; WORD $0x0000 // imull $5243, %edi, %edi + WORD $0xefc1; BYTE $0x11 // shrl $17, %edi + WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0xd8b70f44 // movzwl %ax, %r11d + LONG $0x400d8d48; WORD $0x00ab; BYTE $0x00 // leaq $43840(%rip), %rcx /* _Digits(%rip) */ + LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax + LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) + LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax + LONG $0x40894166; BYTE $0xfc // movw %ax, $-4(%r8) + LONG $0x04b70f42; BYTE $0x59 // movzwl (%rcx,%r11,2), %eax + LONG $0x40894166; BYTE $0xfa // movw %ax, $-6(%r8) + LONG $0xf8588d4d // leaq $-8(%r8), %r11 + LONG $0x790cb70f // movzwl (%rcx,%rdi,2), %ecx + LONG $0x48894166; BYTE $0xf8 // movw %cx, $-8(%r8) + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0x2710ff81; WORD $0x0000 // cmpl $10000, %edi + LONG $0xff3d820f; WORD $0xffff // jb LBB2_4, $-195(%rip) + +LBB2_5: + LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d + LONG $0xf9158d4c; WORD $0x00aa; BYTE $0x00 // leaq $43769(%rip), %r10 /* _Digits(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB2_6: + WORD $0xfa89 // movl %edi, %edx + LONG $0xd1af0f49 // imulq %r9, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0xd8f0ca69; WORD $0xffff // imull $-10000, %edx, %ecx + WORD $0xf901 // addl %edi, %ecx + LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx + WORD $0xd929 // subl %ebx, %ecx + LONG $0x0cb70f41; BYTE $0x4a // movzwl (%r10,%rcx,2), %ecx + LONG $0x4b894166; BYTE $0xfe // movw %cx, $-2(%r11) + LONG $0x04b70f41; BYTE $0x42 // movzwl (%r10,%rax,2), %eax + LONG $0x43894166; BYTE $0xfc // movw %ax, $-4(%r11) + LONG $0xfcc38349 // addq $-4, %r11 + LONG $0xe0ffff81; WORD $0x05f5 // cmpl $99999999, %edi + WORD $0xd789 // movl %edx, %edi + LONG $0xffb8870f; WORD $0xffff // ja LBB2_6, $-72(%rip) + +LBB2_7: + WORD $0xfa83; BYTE $0x64 // cmpl $100, %edx + LONG $0x002d820f; WORD $0x0000 // jb LBB2_9, $45(%rip) + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx + WORD $0xca29 // subl %ecx, %edx + WORD $0xb70f; BYTE $0xca // movzwl %dx, %ecx + LONG $0x81158d48; WORD $0x00aa; BYTE $0x00 // leaq $43649(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x4b894166; BYTE $0xfe // movw %cx, $-2(%r11) + LONG $0xfec38349 // addq $-2, %r11 + WORD $0xc289 // movl %eax, %edx + +LBB2_9: + WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx + LONG $0x0018820f; WORD $0x0000 // jb LBB2_11, $24(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x600d8d48; WORD $0x00aa; BYTE $0x00 // leaq $43616(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x43894166; BYTE $0xfe // movw %ax, $-2(%r11) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB2_11: + WORD $0xc280; BYTE $0x30 // addb $48, %dl + WORD $0x1688 // movb %dl, (%rsi) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_i64toa: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x00b1880f; WORD $0x0000 // js LBB3_12, $177(%rip) + LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi + LONG $0x00b6870f; WORD $0x0000 // ja LBB3_9, $182(%rip) + WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x00148d48 // leaq (%rax,%rax), %rdx + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xf189 // movl %esi, %ecx + WORD $0xc129 // subl %eax, %ecx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi + LONG $0x0017820f; WORD $0x0000 // jb LBB3_4, $23(%rip) + LONG $0xf3058d48; WORD $0x00a9; BYTE $0x00 // leaq $43507(%rip), %rax /* _Digits(%rip) */ + LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x00000be9; BYTE $0x00 // jmp LBB3_5, $11(%rip) + +LBB3_4: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x0046820f; WORD $0x0000 // jb LBB3_6, $70(%rip) + +LBB3_5: + WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx + LONG $0x01ca8348 // orq $1, %rdx + LONG $0xca358d48; WORD $0x00a9; BYTE $0x00 // leaq $43466(%rip), %rsi /* _Digits(%rip) */ + LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB3_7: + LONG $0xb8158d48; WORD $0x00a9; BYTE $0x00 // leaq $43448(%rip), %rdx /* _Digits(%rip) */ + LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB3_8: + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + LONG $0x01c98348 // orq $1, %rcx + LONG $0x9f158d48; WORD $0x00a9; BYTE $0x00 // leaq $43423(%rip), %rdx /* _Digits(%rip) */ + LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx + WORD $0xc289 // movl %eax, %edx + WORD $0xc0ff // incl %eax + WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB3_6: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0xffc8830f; WORD $0xffff // jae LBB3_7, $-56(%rip) + LONG $0xffffd5e9; BYTE $0xff // jmp LBB3_8, $-43(%rip) + +LBB3_12: + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xf748; BYTE $0xde // negq %rsi + LONG $0x000044e8; BYTE $0x00 // callq _u64toa, $68(%rip) + WORD $0xc0ff // incl %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB3_9: + LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi + LONG $0x0006870f; WORD $0x0000 // ja LBB3_10, $6(%rip) + BYTE $0x5d // popq %rbp + LONG $0x00011de9; BYTE $0x00 // jmp _u32toa_medium, $285(%rip) + +LBB3_10: + QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0006870f; WORD $0x0000 // ja LBB3_11, $6(%rip) + BYTE $0x5d // popq %rbp + LONG $0x000244e9; BYTE $0x00 // jmp _u64toa_large_sse2, $580(%rip) + +LBB3_11: + BYTE $0x5d // popq %rbp + LONG $0x00038ee9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $910(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_u64toa: + LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi + LONG $0x00a8870f; WORD $0x0000 // ja LBB4_8, $168(%rip) + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x00148d48 // leaq (%rax,%rax), %rdx + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xf189 // movl %esi, %ecx + WORD $0xc129 // subl %eax, %ecx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi + LONG $0x0017820f; WORD $0x0000 // jb LBB4_3, $23(%rip) + LONG $0xec058d48; WORD $0x00a8; BYTE $0x00 // leaq $43244(%rip), %rax /* _Digits(%rip) */ + LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x00000be9; BYTE $0x00 // jmp LBB4_4, $11(%rip) + +LBB4_3: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x0046820f; WORD $0x0000 // jb LBB4_5, $70(%rip) + +LBB4_4: + WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx + LONG $0x01ca8348 // orq $1, %rdx + LONG $0xc3358d48; WORD $0x00a8; BYTE $0x00 // leaq $43203(%rip), %rsi /* _Digits(%rip) */ + LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB4_6: + LONG $0xb1158d48; WORD $0x00a8; BYTE $0x00 // leaq $43185(%rip), %rdx /* _Digits(%rip) */ + LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB4_7: + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + LONG $0x01c98348 // orq $1, %rcx + LONG $0x98158d48; WORD $0x00a8; BYTE $0x00 // leaq $43160(%rip), %rdx /* _Digits(%rip) */ + LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx + WORD $0xc289 // movl %eax, %edx + WORD $0xc0ff // incl %eax + WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB4_5: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0xffc8830f; WORD $0xffff // jae LBB4_6, $-56(%rip) + LONG $0xffffd5e9; BYTE $0xff // jmp LBB4_7, $-43(%rip) + +LBB4_8: + LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi + LONG $0x0005870f; WORD $0x0000 // ja LBB4_9, $5(%rip) + LONG $0x000029e9; BYTE $0x00 // jmp _u32toa_medium, $41(%rip) + +LBB4_9: + QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0005870f; WORD $0x0000 // ja LBB4_10, $5(%rip) + LONG $0x000151e9; BYTE $0x00 // jmp _u64toa_large_sse2, $337(%rip) + +LBB4_10: + LONG $0x00029ce9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $668(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +_u32toa_medium: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0xf089 // movl %esi, %eax + LONG $0xb71759b9; BYTE $0xd1 // movl $3518437209, %ecx + LONG $0xc8af0f48 // imulq %rax, %rcx + LONG $0x2de9c148 // shrq $45, %rcx + LONG $0x2710d169; WORD $0x0000 // imull $10000, %ecx, %edx + WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d + WORD $0x2941; BYTE $0xd0 // subl %edx, %r8d + LONG $0x83d06948; WORD $0x1bde; BYTE $0x43 // imulq $1125899907, %rax, %rdx + LONG $0x31eac148 // shrq $49, %rdx + WORD $0xe283; BYTE $0xfe // andl $-2, %edx + LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xc129 // subl %eax, %ecx + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0x9680fe81; WORD $0x0098 // cmpl $10000000, %esi + LONG $0x0017820f; WORD $0x0000 // jb LBB5_2, $23(%rip) + LONG $0xed058d48; WORD $0x00a7; BYTE $0x00 // leaq $42989(%rip), %rax /* _Digits(%rip) */ + LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x00000ee9; BYTE $0x00 // jmp LBB5_3, $14(%rip) + +LBB5_2: + WORD $0xc031 // xorl %eax, %eax + LONG $0x4240fe81; WORD $0x000f // cmpl $1000000, %esi + LONG $0x0074820f; WORD $0x0000 // jb LBB5_4, $116(%rip) + +LBB5_3: + WORD $0xd289 // movl %edx, %edx + LONG $0x01ca8348 // orq $1, %rdx + LONG $0xc2358d48; WORD $0x00a7; BYTE $0x00 // leaq $42946(%rip), %rsi /* _Digits(%rip) */ + LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB5_5: + LONG $0xb0158d48; WORD $0x00a7; BYTE $0x00 // leaq $42928(%rip), %rdx /* _Digits(%rip) */ + LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB5_6: + LONG $0xd0b70f41 // movzwl %r8w, %edx + WORD $0xeac1; BYTE $0x02 // shrl $2, %edx + LONG $0x147bd269; WORD $0x0000 // imull $5243, %edx, %edx + WORD $0xeac1; BYTE $0x11 // shrl $17, %edx + WORD $0xf26b; BYTE $0x64 // imull $100, %edx, %esi + WORD $0x2941; BYTE $0xf0 // subl %esi, %r8d + LONG $0xc0b70f45 // movzwl %r8w, %r8d + WORD $0xc989 // movl %ecx, %ecx + LONG $0x01c98348 // orq $1, %rcx + LONG $0x7e0d8d4c; WORD $0x00a7; BYTE $0x00 // leaq $42878(%rip), %r9 /* _Digits(%rip) */ + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xc689 // movl %eax, %esi + WORD $0x0c88; BYTE $0x37 // movb %cl, (%rdi,%rsi) + LONG $0x0cb70f41; BYTE $0x51 // movzwl (%r9,%rdx,2), %ecx + LONG $0x374c8966; BYTE $0x01 // movw %cx, $1(%rdi,%rsi) + LONG $0x0cb70f43; BYTE $0x41 // movzwl (%r9,%r8,2), %ecx + LONG $0x374c8966; BYTE $0x03 // movw %cx, $3(%rdi,%rsi) + WORD $0xc083; BYTE $0x05 // addl $5, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB5_4: + WORD $0xc031 // xorl %eax, %eax + LONG $0x86a0fe81; WORD $0x0001 // cmpl $100000, %esi + LONG $0xff96830f; WORD $0xffff // jae LBB5_5, $-106(%rip) + LONG $0xffffa3e9; BYTE $0xff // jmp LBB5_6, $-93(%rip) + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +LCPI6_0: + QUAD $0x00000000d1b71759 // .quad 3518437209 + QUAD $0x00000000d1b71759 // .quad 3518437209 + +LCPI6_3: + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + +LCPI6_4: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 3, 0x00 +LCPI6_1: + QUAD $0x80003334147b20c5 // .quad -9223315738079846203 + +LCPI6_2: + QUAD $0x8000200008000080 // .quad -9223336852348469120 + + // .p2align 4, 0x90 +_u64toa_large_sse2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax + WORD $0xc629 // subl %eax, %esi + LONG $0xc26ef9c5 // vmovd %edx, %xmm0 + QUAD $0xffffff940d6ff9c5 // vmovdqa $-108(%rip), %xmm1 /* LCPI6_0(%rip) */ + LONG $0xd1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm2 + LONG $0xd273e9c5; BYTE $0x2d // vpsrlq $45, %xmm2, %xmm2 + LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax + LONG $0x6ef9e1c4; BYTE $0xd8 // vmovq %rax, %xmm3 + LONG $0xe3f4e9c5 // vpmuludq %xmm3, %xmm2, %xmm4 + LONG $0xc4faf9c5 // vpsubd %xmm4, %xmm0, %xmm0 + LONG $0xc061e9c5 // vpunpcklwd %xmm0, %xmm2, %xmm0 + LONG $0xf073f9c5; BYTE $0x02 // vpsllq $2, %xmm0, %xmm0 + LONG $0xc070fbc5; BYTE $0x50 // vpshuflw $80, %xmm0, %xmm0 + LONG $0xc070f9c5; BYTE $0x50 // vpshufd $80, %xmm0, %xmm0 + QUAD $0xffffff8e1512fbc5 // vmovddup $-114(%rip), %xmm2 /* LCPI6_1(%rip) */ + LONG $0xc2e4f9c5 // vpmulhuw %xmm2, %xmm0, %xmm0 + QUAD $0xffffff8a2512fbc5 // vmovddup $-118(%rip), %xmm4 /* LCPI6_2(%rip) */ + LONG $0xc4e4f9c5 // vpmulhuw %xmm4, %xmm0, %xmm0 + QUAD $0xffffff562d6ff9c5 // vmovdqa $-170(%rip), %xmm5 /* LCPI6_3(%rip) */ + LONG $0xf5d5f9c5 // vpmullw %xmm5, %xmm0, %xmm6 + LONG $0xf673c9c5; BYTE $0x10 // vpsllq $16, %xmm6, %xmm6 + LONG $0xc6f9f9c5 // vpsubw %xmm6, %xmm0, %xmm0 + LONG $0xf66ef9c5 // vmovd %esi, %xmm6 + LONG $0xc9f4c9c5 // vpmuludq %xmm1, %xmm6, %xmm1 + LONG $0xd173f1c5; BYTE $0x2d // vpsrlq $45, %xmm1, %xmm1 + LONG $0xdbf4f1c5 // vpmuludq %xmm3, %xmm1, %xmm3 + LONG $0xdbfac9c5 // vpsubd %xmm3, %xmm6, %xmm3 + LONG $0xcb61f1c5 // vpunpcklwd %xmm3, %xmm1, %xmm1 + LONG $0xf173f1c5; BYTE $0x02 // vpsllq $2, %xmm1, %xmm1 + LONG $0xc970fbc5; BYTE $0x50 // vpshuflw $80, %xmm1, %xmm1 + LONG $0xc970f9c5; BYTE $0x50 // vpshufd $80, %xmm1, %xmm1 + LONG $0xcae4f1c5 // vpmulhuw %xmm2, %xmm1, %xmm1 + LONG $0xcce4f1c5 // vpmulhuw %xmm4, %xmm1, %xmm1 + LONG $0xd5d5f1c5 // vpmullw %xmm5, %xmm1, %xmm2 + LONG $0xf273e9c5; BYTE $0x10 // vpsllq $16, %xmm2, %xmm2 + LONG $0xcaf9f1c5 // vpsubw %xmm2, %xmm1, %xmm1 + LONG $0xc167f9c5 // vpackuswb %xmm1, %xmm0, %xmm0 + QUAD $0xffffff100dfcf9c5 // vpaddb $-240(%rip), %xmm0, %xmm1 /* LCPI6_4(%rip) */ + LONG $0xd2efe9c5 // vpxor %xmm2, %xmm2, %xmm2 + LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 + LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax + WORD $0xd0f7 // notl %eax + LONG $0x0080000d; BYTE $0x00 // orl $32768, %eax + WORD $0xbc0f; BYTE $0xc8 // bsfl %eax, %ecx + LONG $0x000010b8; BYTE $0x00 // movl $16, %eax + WORD $0xc829 // subl %ecx, %eax + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x68158d48; WORD $0x00cd; BYTE $0x00 // leaq $52584(%rip), %rdx /* _VecShiftShuffles(%rip) */ + LONG $0x0071e2c4; WORD $0x1104 // vpshufb (%rcx,%rdx), %xmm1, %xmm0 + LONG $0x077ffac5 // vmovdqu %xmm0, (%rdi) + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 + +LCPI7_0: + QUAD $0x00000000d1b71759 // .quad 3518437209 + QUAD $0x00000000d1b71759 // .quad 3518437209 + +LCPI7_3: + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + +LCPI7_4: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 3, 0x00 +LCPI7_1: + QUAD $0x80003334147b20c5 // .quad -9223315738079846203 + +LCPI7_2: + QUAD $0x8000200008000080 // .quad -9223336852348469120 + + // .p2align 4, 0x90 +_u64toa_xlarge_sse2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + QUAD $0x652fb1137857b948; WORD $0x39a5 // movabsq $4153837486827862103, %rcx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x33eac148 // shrq $51, %rdx + QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax + LONG $0xc2af0f48 // imulq %rdx, %rax + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + WORD $0xfa83; BYTE $0x09 // cmpl $9, %edx + LONG $0x000f870f; WORD $0x0000 // ja LBB7_2, $15(%rip) + WORD $0xc280; BYTE $0x30 // addb $48, %dl + WORD $0x1788 // movb %dl, (%rdi) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + LONG $0x0000a7e9; BYTE $0x00 // jmp LBB7_7, $167(%rip) + +LBB7_2: + WORD $0xfa83; BYTE $0x63 // cmpl $99, %edx + LONG $0x001a870f; WORD $0x0000 // ja LBB7_4, $26(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x5d0d8d48; WORD $0x00a5; BYTE $0x00 // leaq $42333(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx + LONG $0x000084e9; BYTE $0x00 // jmp LBB7_7, $132(%rip) + +LBB7_4: + WORD $0xd089 // movl %edx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x03e7fa81; WORD $0x0000 // cmpl $999, %edx + LONG $0x0037870f; WORD $0x0000 // ja LBB7_6, $55(%rip) + WORD $0xc083; BYTE $0x30 // addl $48, %eax + WORD $0x0788 // movb %al, (%rdi) + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x02 // shrl $2, %ecx + LONG $0x147bc969; WORD $0x0000 // imull $5243, %ecx, %ecx + WORD $0xe9c1; BYTE $0x11 // shrl $17, %ecx + WORD $0xc96b; BYTE $0x64 // imull $100, %ecx, %ecx + WORD $0xc829 // subl %ecx, %eax + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0x0d0d8d48; WORD $0x00a5; BYTE $0x00 // leaq $42253(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x01478966 // movw %ax, $1(%rdi) + LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx + LONG $0x000033e9; BYTE $0x00 // jmp LBB7_7, $51(%rip) + +LBB7_6: + WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx + WORD $0xca29 // subl %ecx, %edx + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0xec0d8d48; WORD $0x00a4; BYTE $0x00 // leaq $42220(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + LONG $0x4114b60f // movzbl (%rcx,%rax,2), %edx + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax + WORD $0x5788; BYTE $0x02 // movb %dl, $2(%rdi) + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0x0844b60f; BYTE $0x01 // movzbl $1(%rax,%rcx), %eax + WORD $0x4788; BYTE $0x03 // movb %al, $3(%rdi) + LONG $0x000004b9; BYTE $0x00 // movl $4, %ecx + +LBB7_7: + QUAD $0x77118461cefdba48; WORD $0xabcc // movabsq $-6067343680855748867, %rdx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe2 // mulq %rdx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0xc26ef9c5 // vmovd %edx, %xmm0 + QUAD $0xfffffeb80d6ff9c5 // vmovdqa $-328(%rip), %xmm1 /* LCPI7_0(%rip) */ + LONG $0xd1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm2 + LONG $0xd273e9c5; BYTE $0x2d // vpsrlq $45, %xmm2, %xmm2 + LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax + LONG $0x6ef9e1c4; BYTE $0xd8 // vmovq %rax, %xmm3 + LONG $0xe3f4e9c5 // vpmuludq %xmm3, %xmm2, %xmm4 + LONG $0xc4faf9c5 // vpsubd %xmm4, %xmm0, %xmm0 + LONG $0xc061e9c5 // vpunpcklwd %xmm0, %xmm2, %xmm0 + LONG $0xf073f9c5; BYTE $0x02 // vpsllq $2, %xmm0, %xmm0 + LONG $0xc070fbc5; BYTE $0x50 // vpshuflw $80, %xmm0, %xmm0 + LONG $0xc070f9c5; BYTE $0x50 // vpshufd $80, %xmm0, %xmm0 + QUAD $0xfffffeb21512fbc5 // vmovddup $-334(%rip), %xmm2 /* LCPI7_1(%rip) */ + LONG $0xc2e4f9c5 // vpmulhuw %xmm2, %xmm0, %xmm0 + QUAD $0xfffffeae2512fbc5 // vmovddup $-338(%rip), %xmm4 /* LCPI7_2(%rip) */ + LONG $0xc4e4f9c5 // vpmulhuw %xmm4, %xmm0, %xmm0 + QUAD $0xfffffe7a2d6ff9c5 // vmovdqa $-390(%rip), %xmm5 /* LCPI7_3(%rip) */ + LONG $0xf5d5f9c5 // vpmullw %xmm5, %xmm0, %xmm6 + LONG $0xf673c9c5; BYTE $0x10 // vpsllq $16, %xmm6, %xmm6 + LONG $0xc6f9f9c5 // vpsubw %xmm6, %xmm0, %xmm0 + LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax + WORD $0xc629 // subl %eax, %esi + LONG $0xf66ef9c5 // vmovd %esi, %xmm6 + LONG $0xc9f4c9c5 // vpmuludq %xmm1, %xmm6, %xmm1 + LONG $0xd173f1c5; BYTE $0x2d // vpsrlq $45, %xmm1, %xmm1 + LONG $0xdbf4f1c5 // vpmuludq %xmm3, %xmm1, %xmm3 + LONG $0xdbfac9c5 // vpsubd %xmm3, %xmm6, %xmm3 + LONG $0xcb61f1c5 // vpunpcklwd %xmm3, %xmm1, %xmm1 + LONG $0xf173f1c5; BYTE $0x02 // vpsllq $2, %xmm1, %xmm1 + LONG $0xc970fbc5; BYTE $0x50 // vpshuflw $80, %xmm1, %xmm1 + LONG $0xc970f9c5; BYTE $0x50 // vpshufd $80, %xmm1, %xmm1 + LONG $0xcae4f1c5 // vpmulhuw %xmm2, %xmm1, %xmm1 + LONG $0xcce4f1c5 // vpmulhuw %xmm4, %xmm1, %xmm1 + LONG $0xd5d5f1c5 // vpmullw %xmm5, %xmm1, %xmm2 + LONG $0xf273e9c5; BYTE $0x10 // vpsllq $16, %xmm2, %xmm2 + LONG $0xcaf9f1c5 // vpsubw %xmm2, %xmm1, %xmm1 + LONG $0xc167f9c5 // vpackuswb %xmm1, %xmm0, %xmm0 + QUAD $0xfffffe2c05fcf9c5 // vpaddb $-468(%rip), %xmm0, %xmm0 /* LCPI7_4(%rip) */ + WORD $0xc889 // movl %ecx, %eax + LONG $0x047ffac5; BYTE $0x07 // vmovdqu %xmm0, (%rdi,%rax) + WORD $0xc983; BYTE $0x10 // orl $16, %ecx + WORD $0xc889 // movl %ecx, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI8_0: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI8_1: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI8_2: + QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' + + // .p2align 4, 0x90 +_quote: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x20ec8348 // subq $32, %rsp + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + WORD $0x8b4c; BYTE $0x11 // movq (%rcx), %r10 + LONG $0x01c0f641 // testb $1, %r8b + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0x780d8d48; WORD $0x00cb; BYTE $0x00 // leaq $52088(%rip), %rcx /* __SingleQuoteTab(%rip) */ + LONG $0x71258d4c; WORD $0x00db; BYTE $0x00 // leaq $56177(%rip), %r12 /* __DoubleQuoteTab(%rip) */ + LONG $0xe1440f4c // cmoveq %rcx, %r12 + QUAD $0x00000000f50c8d48 // leaq (,%rsi,8), %rcx + WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 + LONG $0x03ec8d0f; WORD $0x0000 // jge LBB8_56, $1004(%rip) + WORD $0x894d; BYTE $0xfe // movq %r15, %r14 + WORD $0x8949; BYTE $0xf9 // movq %rdi, %r9 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x03cc840f; WORD $0x0000 // je LBB8_79, $972(%rip) + LONG $0xc85d894c // movq %r11, $-56(%rbp) + QUAD $0xffffff71056ff9c5 // vmovdqa $-143(%rip), %xmm0 /* LCPI8_0(%rip) */ + QUAD $0xffffff790d6ff9c5 // vmovdqa $-135(%rip), %xmm1 /* LCPI8_1(%rip) */ + QUAD $0xffffff81156ff9c5 // vmovdqa $-127(%rip), %xmm2 /* LCPI8_2(%rip) */ + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + LONG $0xd07d894c // movq %r15, $-48(%rbp) + WORD $0x894d; BYTE $0xfe // movq %r15, %r14 + LONG $0xc065894c // movq %r12, $-64(%rbp) + +LBB8_3: + WORD $0x8949; BYTE $0xc9 // movq %rcx, %r9 + LONG $0x10f88348 // cmpq $16, %rax + WORD $0x9d0f; BYTE $0xc3 // setge %bl + WORD $0x894d; BYTE $0xd4 // movq %r10, %r12 + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + LONG $0x10fa8349 // cmpq $16, %r10 + LONG $0x00738c0f; WORD $0x0000 // jl LBB8_10, $115(%rip) + LONG $0x10f88348 // cmpq $16, %rax + LONG $0x00698c0f; WORD $0x0000 // jl LBB8_10, $105(%rip) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + + // .p2align 4, 0x90 +LBB8_6: + LONG $0x6f7a81c4; WORD $0x391c // vmovdqu (%r9,%r15), %xmm3 + LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 + LONG $0xe974e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm5 + LONG $0xe4ebd1c5 // vpor %xmm4, %xmm5, %xmm4 + LONG $0x7f7a81c4; WORD $0x3e1c // vmovdqu %xmm3, (%r14,%r15) + LONG $0xeadae1c5 // vpminub %xmm2, %xmm3, %xmm5 + LONG $0xdd74e1c5 // vpcmpeqb %xmm5, %xmm3, %xmm3 + LONG $0xdbebd9c5 // vpor %xmm3, %xmm4, %xmm3 + LONG $0xf3d7f9c5 // vpmovmskb %xmm3, %esi + WORD $0xf685 // testl %esi, %esi + LONG $0x012a850f; WORD $0x0000 // jne LBB8_23, $298(%rip) + LONG $0xf05a8d4c // leaq $-16(%rdx), %r11 + LONG $0xf0618d4c // leaq $-16(%rcx), %r12 + LONG $0x10c78349 // addq $16, %r15 + LONG $0x20fa8348 // cmpq $32, %rdx + WORD $0x9d0f; BYTE $0xc3 // setge %bl + LONG $0x00108c0f; WORD $0x0000 // jl LBB8_9, $16(%rip) + WORD $0x894c; BYTE $0xda // movq %r11, %rdx + LONG $0x1ff98348 // cmpq $31, %rcx + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + LONG $0xffa78f0f; WORD $0xffff // jg LBB8_6, $-89(%rip) + +LBB8_9: + LONG $0x392c8d4f // leaq (%r9,%r15), %r13 + WORD $0x014d; BYTE $0xf7 // addq %r14, %r15 + +LBB8_10: + WORD $0xdb84 // testb %bl, %bl + LONG $0x0063840f; WORD $0x0000 // je LBB8_14, $99(%rip) + LONG $0x6f7ac1c4; WORD $0x005d // vmovdqu (%r13), %xmm3 + LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 + LONG $0xe974e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm5 + LONG $0xe4ebd1c5 // vpor %xmm4, %xmm5, %xmm4 + LONG $0xeadae1c5 // vpminub %xmm2, %xmm3, %xmm5 + LONG $0xed74e1c5 // vpcmpeqb %xmm5, %xmm3, %xmm5 + LONG $0xe5ebd9c5 // vpor %xmm5, %xmm4, %xmm4 + LONG $0xccd7f9c5 // vpmovmskb %xmm4, %ecx + LONG $0x0000c981; WORD $0x0001 // orl $65536, %ecx + LONG $0xd9bc0f44 // bsfl %ecx, %r11d + LONG $0x7ef9e1c4; BYTE $0xd9 // vmovq %xmm3, %rcx + WORD $0x394d; BYTE $0xdc // cmpq %r11, %r12 + LONG $0x00c88d0f; WORD $0x0000 // jge LBB8_24, $200(%rip) + LONG $0x08fc8349 // cmpq $8, %r12 + LONG $0x00fd820f; WORD $0x0000 // jb LBB8_28, $253(%rip) + WORD $0x8949; BYTE $0x0f // movq %rcx, (%r15) + LONG $0x085d8d4d // leaq $8(%r13), %r11 + LONG $0x08c78349 // addq $8, %r15 + LONG $0x245c8d49; BYTE $0xf8 // leaq $-8(%r12), %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x00f38d0f; WORD $0x0000 // jge LBB8_29, $243(%rip) + LONG $0x000100e9; BYTE $0x00 // jmp LBB8_30, $256(%rip) + +LBB8_14: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x006e8e0f; WORD $0x0000 // jle LBB8_21, $110(%rip) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x00658e0f; WORD $0x0000 // jle LBB8_21, $101(%rip) + LONG $0xb84d894c // movq %r9, $-72(%rbp) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB8_17: + LONG $0x74b60f43; WORD $0x000d // movzbl (%r13,%r9), %esi + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + LONG $0x04e3c148 // shlq $4, %rbx + LONG $0xec158d48; WORD $0x00c9; BYTE $0x00 // leaq $51692(%rip), %rdx /* __SingleQuoteTab(%rip) */ + LONG $0x133c8348; BYTE $0x00 // cmpq $0, (%rbx,%rdx) + LONG $0x008b850f; WORD $0x0000 // jne LBB8_27, $139(%rip) + LONG $0x0b048d4d // leaq (%r11,%rcx), %r8 + LONG $0x0f348843 // movb %sil, (%r15,%r9) + LONG $0xff598d48 // leaq $-1(%rcx), %rbx + LONG $0x02f88349 // cmpq $2, %r8 + LONG $0x00138c0f; WORD $0x0000 // jl LBB8_20, $19(%rip) + WORD $0x014c; BYTE $0xe1 // addq %r12, %rcx + WORD $0xff49; BYTE $0xc1 // incq %r9 + LONG $0x01f98348 // cmpq $1, %rcx + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx + LONG $0xffb88f0f; WORD $0xffff // jg LBB8_17, $-72(%rip) + +LBB8_20: + WORD $0x2949; BYTE $0xdd // subq %rbx, %r13 + WORD $0x0149; BYTE $0xdb // addq %rbx, %r11 + LONG $0xb84d8b4c // movq $-72(%rbp), %r9 + +LBB8_21: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0xc0658b4c // movq $-64(%rbp), %r12 + LONG $0x0043840f; WORD $0x0000 // je LBB8_26, $67(%rip) + WORD $0xf749; BYTE $0xd5 // notq %r13 + WORD $0x014d; BYTE $0xcd // addq %r9, %r13 + LONG $0x000129e9; BYTE $0x00 // jmp LBB8_41, $297(%rip) + +LBB8_23: + LONG $0xcebc0f66 // bsfw %si, %cx + LONG $0xe9b70f44 // movzwl %cx, %r13d + WORD $0x014d; BYTE $0xfd // addq %r15, %r13 + LONG $0x000115e9; BYTE $0x00 // jmp LBB8_40, $277(%rip) + +LBB8_24: + LONG $0x08fb8341 // cmpl $8, %r11d + LONG $0x00a4820f; WORD $0x0000 // jb LBB8_34, $164(%rip) + WORD $0x8949; BYTE $0x0f // movq %rcx, (%r15) + LONG $0x08658d4d // leaq $8(%r13), %r12 + LONG $0x08c78349 // addq $8, %r15 + LONG $0xf85b8d49 // leaq $-8(%r11), %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x009b830f; WORD $0x0000 // jae LBB8_35, $155(%rip) + LONG $0x0000a9e9; BYTE $0x00 // jmp LBB8_36, $169(%rip) + +LBB8_26: + WORD $0x294d; BYTE $0xcd // subq %r9, %r13 + LONG $0x0000e9e9; BYTE $0x00 // jmp LBB8_41, $233(%rip) + +LBB8_27: + LONG $0xb84d8b4c // movq $-72(%rbp), %r9 + WORD $0x294d; BYTE $0xcd // subq %r9, %r13 + WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 + LONG $0x0000d6e9; BYTE $0x00 // jmp LBB8_40, $214(%rip) + +LBB8_28: + WORD $0x894d; BYTE $0xeb // movq %r13, %r11 + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x00128c0f; WORD $0x0000 // jl LBB8_30, $18(%rip) + +LBB8_29: + WORD $0x8b41; BYTE $0x0b // movl (%r11), %ecx + WORD $0x8941; BYTE $0x0f // movl %ecx, (%r15) + LONG $0x04c38349 // addq $4, %r11 + LONG $0x04c78349 // addq $4, %r15 + LONG $0xfcc38348 // addq $-4, %rbx + +LBB8_30: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0022820f; WORD $0x0000 // jb LBB8_31, $34(%rip) + LONG $0x0bb70f41 // movzwl (%r11), %ecx + LONG $0x0f894166 // movw %cx, (%r15) + LONG $0x02c38349 // addq $2, %r11 + LONG $0x02c78349 // addq $2, %r15 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x000e850f; WORD $0x0000 // jne LBB8_32, $14(%rip) + LONG $0x000010e9; BYTE $0x00 // jmp LBB8_33, $16(%rip) + +LBB8_31: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0007840f; WORD $0x0000 // je LBB8_33, $7(%rip) + +LBB8_32: + LONG $0x0bb60f41 // movzbl (%r11), %ecx + WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) + +LBB8_33: + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0xf749; BYTE $0xd4 // notq %r12 + WORD $0x014d; BYTE $0xcc // addq %r9, %r12 + WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 + LONG $0x000067e9; BYTE $0x00 // jmp LBB8_40, $103(%rip) + +LBB8_34: + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + WORD $0x894c; BYTE $0xdb // movq %r11, %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x0013820f; WORD $0x0000 // jb LBB8_36, $19(%rip) + +LBB8_35: + LONG $0x240c8b41 // movl (%r12), %ecx + WORD $0x8941; BYTE $0x0f // movl %ecx, (%r15) + LONG $0x04c48349 // addq $4, %r12 + LONG $0x04c78349 // addq $4, %r15 + LONG $0xfcc38348 // addq $-4, %rbx + +LBB8_36: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0023820f; WORD $0x0000 // jb LBB8_37, $35(%rip) + LONG $0x0cb70f41; BYTE $0x24 // movzwl (%r12), %ecx + LONG $0x0f894166 // movw %cx, (%r15) + LONG $0x02c48349 // addq $2, %r12 + LONG $0x02c78349 // addq $2, %r15 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x000e850f; WORD $0x0000 // jne LBB8_38, $14(%rip) + LONG $0x000011e9; BYTE $0x00 // jmp LBB8_39, $17(%rip) + +LBB8_37: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0008840f; WORD $0x0000 // je LBB8_39, $8(%rip) + +LBB8_38: + LONG $0x0cb60f41; BYTE $0x24 // movzbl (%r12), %ecx + WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) + +LBB8_39: + WORD $0x294d; BYTE $0xcd // subq %r9, %r13 + WORD $0x014d; BYTE $0xdd // addq %r11, %r13 + +LBB8_40: + LONG $0xc0658b4c // movq $-64(%rbp), %r12 + +LBB8_41: + QUAD $0x000300000001bb49; WORD $0x0000 // movabsq $12884901889, %r11 + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x0313880f; WORD $0x0000 // js LBB8_82, $787(%rip) + WORD $0x014d; BYTE $0xee // addq %r13, %r14 + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00c2840f; WORD $0x0000 // je LBB8_78, $194(%rip) + WORD $0x294d; BYTE $0xea // subq %r13, %r10 + LONG $0x000015e9; BYTE $0x00 // jmp LBB8_45, $21(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB8_44: + WORD $0x0149; BYTE $0xf6 // addq %rsi, %r14 + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00a5840f; WORD $0x0000 // je LBB8_78, $165(%rip) + +LBB8_45: + LONG $0x0cb60f43; BYTE $0x29 // movzbl (%r9,%r13), %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x0c148b41 // movl (%r12,%rcx), %edx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0082840f; WORD $0x0000 // je LBB8_53, $130(%rip) + WORD $0x6348; BYTE $0xf2 // movslq %edx, %rsi + WORD $0x2949; BYTE $0xf2 // subq %rsi, %r10 + LONG $0x02a28c0f; WORD $0x0000 // jl LBB8_80, $674(%rip) + LONG $0x20e2c148 // shlq $32, %rdx + LONG $0x0c1c8d49 // leaq (%r12,%rcx), %rbx + LONG $0x08c38348 // addq $8, %rbx + WORD $0x394c; BYTE $0xda // cmpq %r11, %rdx + LONG $0x002a8c0f; WORD $0x0000 // jl LBB8_49, $42(%rip) + WORD $0x0b8b // movl (%rbx), %ecx + WORD $0x8941; BYTE $0x0e // movl %ecx, (%r14) + LONG $0x04c38348 // addq $4, %rbx + LONG $0x04468d4d // leaq $4(%r14), %r8 + LONG $0xfc4e8d48 // leaq $-4(%rsi), %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x001f830f; WORD $0x0000 // jae LBB8_50, $31(%rip) + LONG $0x00002de9; BYTE $0x00 // jmp LBB8_51, $45(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB8_49: + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x0013820f; WORD $0x0000 // jb LBB8_51, $19(%rip) + +LBB8_50: + WORD $0xb70f; BYTE $0x13 // movzwl (%rbx), %edx + LONG $0x10894166 // movw %dx, (%r8) + LONG $0x02c38348 // addq $2, %rbx + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec18348 // addq $-2, %rcx + +LBB8_51: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0xff64840f; WORD $0xffff // je LBB8_44, $-156(%rip) + WORD $0xb60f; BYTE $0x0b // movzbl (%rbx), %ecx + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + LONG $0xffff59e9; BYTE $0xff // jmp LBB8_44, $-167(%rip) + +LBB8_53: + LONG $0x290c8d4b // leaq (%r9,%r13), %rcx + WORD $0x294c; BYTE $0xe8 // subq %r13, %rax + LONG $0xfc69850f; WORD $0xffff // jne LBB8_3, $-919(%rip) + +LBB8_78: + WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 + LONG $0xc85d8b4c // movq $-56(%rbp), %r11 + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + +LBB8_79: + WORD $0x294d; BYTE $0xfe // subq %r15, %r14 + WORD $0x894d; BYTE $0x33 // movq %r14, (%r11) + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0x00021ae9; BYTE $0x00 // jmp LBB8_81, $538(%rip) + +LBB8_56: + QUAD $0xfffffb98056ff9c5 // vmovdqa $-1128(%rip), %xmm0 /* LCPI8_0(%rip) */ + QUAD $0xfffffba00d6ff9c5 // vmovdqa $-1120(%rip), %xmm1 /* LCPI8_1(%rip) */ + QUAD $0xfffffba8156ff9c5 // vmovdqa $-1112(%rip), %xmm2 /* LCPI8_2(%rip) */ + LONG $0x510d8d4c; WORD $0x00e7; BYTE $0x00 // leaq $59217(%rip), %r9 /* __EscTab(%rip) */ + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + +LBB8_57: + LONG $0x10fb8348 // cmpq $16, %rbx + LONG $0x00438c0f; WORD $0x0000 // jl LBB8_60, $67(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB8_58: + LONG $0x1f6ffac5 // vmovdqu (%rdi), %xmm3 + LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 + LONG $0xe974e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm5 + LONG $0xe4ebd1c5 // vpor %xmm4, %xmm5, %xmm4 + LONG $0x1e7ffac5 // vmovdqu %xmm3, (%rsi) + LONG $0xeadae1c5 // vpminub %xmm2, %xmm3, %xmm5 + LONG $0xdd74e1c5 // vpcmpeqb %xmm5, %xmm3, %xmm3 + LONG $0xdbebd9c5 // vpor %xmm3, %xmm4, %xmm3 + LONG $0xcbd7f9c5 // vpmovmskb %xmm3, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0120850f; WORD $0x0000 // jne LBB8_70, $288(%rip) + LONG $0x10c78348 // addq $16, %rdi + LONG $0x10c68348 // addq $16, %rsi + LONG $0xf0c38348 // addq $-16, %rbx + LONG $0x10fb8348 // cmpq $16, %rbx + LONG $0xffbe830f; WORD $0xffff // jae LBB8_58, $-66(%rip) + +LBB8_60: + LONG $0x08fb8348 // cmpq $8, %rbx + LONG $0x007b8c0f; WORD $0x0000 // jl LBB8_64, $123(%rip) + WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + LONG $0x0157b60f // movzbl $1(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xd200 // addb %dl, %dl + LONG $0x09140a42 // orb (%rcx,%r9), %dl + LONG $0x024fb60f // movzbl $2(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl + WORD $0xd108 // orb %dl, %cl + LONG $0x0357b60f // movzbl $3(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl + WORD $0xca08 // orb %cl, %dl + WORD $0x8b48; BYTE $0x0f // movq (%rdi), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x0117850f; WORD $0x0000 // jne LBB8_75, $279(%rip) + LONG $0x044fb60f // movzbl $4(%rdi), %ecx + LONG $0x0557b60f // movzbl $5(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xd200 // addb %dl, %dl + LONG $0x09140a42 // orb (%rcx,%r9), %dl + LONG $0x064fb60f // movzbl $6(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl + WORD $0xd108 // orb %dl, %cl + LONG $0x0757b60f // movzbl $7(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl + WORD $0xca08 // orb %cl, %dl + LONG $0x00ed850f; WORD $0x0000 // jne LBB8_76, $237(%rip) + LONG $0x08c68348 // addq $8, %rsi + LONG $0x08c78348 // addq $8, %rdi + LONG $0xf8c38348 // addq $-8, %rbx + +LBB8_64: + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x00448c0f; WORD $0x0000 // jl LBB8_67, $68(%rip) + WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + LONG $0x0157b60f // movzbl $1(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xd200 // addb %dl, %dl + LONG $0x09140a42 // orb (%rcx,%r9), %dl + LONG $0x024fb60f // movzbl $2(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl + WORD $0xd108 // orb %dl, %cl + LONG $0x0357b60f // movzbl $3(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl + WORD $0xca08 // orb %cl, %dl + WORD $0x0f8b // movl (%rdi), %ecx + WORD $0x0e89 // movl %ecx, (%rsi) + LONG $0x0094850f; WORD $0x0000 // jne LBB8_75, $148(%rip) + LONG $0x04c68348 // addq $4, %rsi + LONG $0x04c78348 // addq $4, %rdi + LONG $0xfcc38348 // addq $-4, %rbx + +LBB8_67: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00aa8e0f; WORD $0x0000 // jle LBB8_77, $170(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +LBB8_68: + WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + LONG $0x093c8042; BYTE $0x00 // cmpb $0, (%rcx,%r9) + LONG $0x002e850f; WORD $0x0000 // jne LBB8_72, $46(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0x0e88 // movb %cl, (%rsi) + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xff4b8d48 // leaq $-1(%rbx), %rcx + LONG $0x01fb8348 // cmpq $1, %rbx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0xffd98f0f; WORD $0xffff // jg LBB8_68, $-39(%rip) + LONG $0x00007ce9; BYTE $0x00 // jmp LBB8_77, $124(%rip) + +LBB8_70: + LONG $0xc9bc0f66 // bsfw %cx, %cx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + +LBB8_71: + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi + WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + +LBB8_72: + WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + BYTE $0x90 // .p2align 4, 0x90 + +LBB8_73: + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x0c346349 // movslq (%r12,%rcx), %rsi + LONG $0x0c4c8b49; BYTE $0x08 // movq $8(%r12,%rcx), %rcx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x00458c0f; WORD $0x0000 // jl LBB8_77, $69(%rip) + WORD $0xff48; BYTE $0xcb // decq %rbx + LONG $0x014fb60f // movzbl $1(%rdi), %ecx + WORD $0xff48; BYTE $0xc7 // incq %rdi + LONG $0x093c8042; BYTE $0x00 // cmpb $0, (%rcx,%r9) + LONG $0xffc8850f; WORD $0xffff // jne LBB8_73, $-56(%rip) + LONG $0xfffe58e9; BYTE $0xff // jmp LBB8_57, $-424(%rip) + +LBB8_75: + WORD $0xb60f; BYTE $0xca // movzbl %dl, %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + LONG $0xffffabe9; BYTE $0xff // jmp LBB8_71, $-85(%rip) + +LBB8_76: + WORD $0xb60f; BYTE $0xca // movzbl %dl, %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + LONG $0x04518d48 // leaq $4(%rcx), %rdx + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi + LONG $0x04c78348 // addq $4, %rdi + WORD $0x2948; BYTE $0xd3 // subq %rdx, %rbx + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + LONG $0x04c68348 // addq $4, %rsi + LONG $0xffff94e9; BYTE $0xff // jmp LBB8_72, $-108(%rip) + +LBB8_77: + WORD $0x294c; BYTE $0xfe // subq %r15, %rsi + WORD $0x8949; BYTE $0x33 // movq %rsi, (%r11) + LONG $0x000017e9; BYTE $0x00 // jmp LBB8_81, $23(%rip) + +LBB8_80: + LONG $0xd0752b4c // subq $-48(%rbp), %r14 + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x30 // movq %r14, (%rax) + WORD $0x294c; BYTE $0xcf // subq %r9, %rdi + WORD $0xf749; BYTE $0xd5 // notq %r13 + WORD $0x0149; BYTE $0xfd // addq %rdi, %r13 + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + +LBB8_81: + LONG $0x20c48348 // addq $32, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB8_82: + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + WORD $0x294c; BYTE $0xcf // subq %r9, %rdi + WORD $0x014c; BYTE $0xef // addq %r13, %rdi + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0xffffcfe9; BYTE $0xff // jmp LBB8_81, $-49(%rip) + LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI9_0: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI9_1: + BYTE $0xf0 // .byte 240 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + + // .p2align 4, 0x90 +_unquote: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x48ec8348 // subq $72, %rsp + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0683840f; WORD $0x0000 // je LBB9_1, $1667(%rip) + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8945; BYTE $0xc2 // movl %r8d, %r10d + LONG $0x01e28341 // andl $1, %r10d + LONG $0xd4258d4c; WORD $0x00e5; BYTE $0x00 // leaq $58836(%rip), %r12 /* __UnquoteTab(%rip) */ + QUAD $0xffffffbc0d6ff9c5 // vmovdqa $-68(%rip), %xmm1 /* LCPI9_1(%rip) */ + QUAD $0xffffffa4156ff9c5 // vmovdqa $-92(%rip), %xmm2 /* LCPI9_0(%rip) */ + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + LONG $0xb845894c // movq %r8, $-72(%rbp) + +LBB9_4: + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x000d850f; WORD $0x0000 // jne LBB9_6, $13(%rip) + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + LONG $0x0000c5e9; BYTE $0x00 // jmp LBB9_18, $197(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_6: + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + WORD $0x894d; BYTE $0xfb // movq %r15, %r11 + LONG $0x10fd8349 // cmpq $16, %r13 + LONG $0x00458c0f; WORD $0x0000 // jl LBB9_12, $69(%rip) + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB9_8: + LONG $0x6f7ac1c4; WORD $0x0f04 // vmovdqu (%r15,%rcx), %xmm0 + LONG $0x7f7ac1c4; WORD $0x0e04 // vmovdqu %xmm0, (%r14,%rcx) + LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x006b850f; WORD $0x0000 // jne LBB9_9, $107(%rip) + LONG $0xf0488d4c // leaq $-16(%rax), %r9 + LONG $0x10c18348 // addq $16, %rcx + LONG $0x1ff88348 // cmpq $31, %rax + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0xffcf870f; WORD $0xffff // ja LBB9_8, $-49(%rip) + LONG $0x0f1c8d4d // leaq (%r15,%rcx), %r11 + WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + +LBB9_12: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x05e2840f; WORD $0x0000 // je LBB9_2, $1506(%rip) + WORD $0xc031 // xorl %eax, %eax + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_14: + LONG $0x1cb60f41; BYTE $0x03 // movzbl (%r11,%rax), %ebx + WORD $0xfb80; BYTE $0x5c // cmpb $92, %bl + LONG $0x0014840f; WORD $0x0000 // je LBB9_16, $20(%rip) + WORD $0x1c88; BYTE $0x01 // movb %bl, (%rcx,%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0xffe3850f; WORD $0xffff // jne LBB9_14, $-29(%rip) + LONG $0x0005b1e9; BYTE $0x00 // jmp LBB9_2, $1457(%rip) + +LBB9_16: + WORD $0x294d; BYTE $0xfb // subq %r15, %r11 + WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + LONG $0xfffb8349 // cmpq $-1, %r11 + LONG $0x001e850f; WORD $0x0000 // jne LBB9_18, $30(%rip) + LONG $0x00059ce9; BYTE $0x00 // jmp LBB9_2, $1436(%rip) + +LBB9_9: + LONG $0xc3bc0f66 // bsfw %bx, %ax + LONG $0xd8b70f44 // movzwl %ax, %r11d + WORD $0x0149; BYTE $0xcb // addq %rcx, %r11 + LONG $0xfffb8349 // cmpq $-1, %r11 + LONG $0x0587840f; WORD $0x0000 // je LBB9_2, $1415(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB9_18: + LONG $0x024b8d49 // leaq $2(%r11), %rcx + WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 + LONG $0x0642880f; WORD $0x0000 // js LBB9_19, $1602(%rip) + WORD $0x014d; BYTE $0xdf // addq %r11, %r15 + LONG $0x02c78349 // addq $2, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x028d850f; WORD $0x0000 // jne LBB9_21, $653(%rip) + +LBB9_32: + WORD $0x014d; BYTE $0xde // addq %r11, %r14 + LONG $0x47b60f41; BYTE $0xff // movzbl $-1(%r15), %eax + LONG $0x04b60f42; BYTE $0x20 // movzbl (%rax,%r12), %eax + LONG $0x0000ff3d; BYTE $0x00 // cmpl $255, %eax + LONG $0x002b840f; WORD $0x0000 // je LBB9_38, $43(%rip) + WORD $0xc085 // testl %eax, %eax + LONG $0x062d840f; WORD $0x0000 // je LBB9_34, $1581(%rip) + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfedd850f; WORD $0xffff // jne LBB9_4, $-291(%rip) + LONG $0x000611e9; BYTE $0x00 // jmp LBB9_37, $1553(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_38: + LONG $0x03fd8349 // cmpq $3, %r13 + LONG $0x05e5860f; WORD $0x0000 // jbe LBB9_19, $1509(%rip) + WORD $0x8b41; BYTE $0x1f // movl (%r15), %ebx + WORD $0xd989 // movl %ebx, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0xcfd0838d; WORD $0xcfcf // leal $-808464432(%rbx), %eax + LONG $0x8080e181; WORD $0x8080 // andl $-2139062144, %ecx + WORD $0xc185 // testl %eax, %ecx + LONG $0x0516850f; WORD $0x0000 // jne LBB9_43, $1302(%rip) + LONG $0x1919838d; WORD $0x1919 // leal $421075225(%rbx), %eax + WORD $0xd809 // orl %ebx, %eax + LONG $0x808080a9; BYTE $0x80 // testl $-2139062144, %eax + LONG $0x0503850f; WORD $0x0000 // jne LBB9_43, $1283(%rip) + WORD $0xd889 // movl %ebx, %eax + LONG $0x7f7f7f25; BYTE $0x7f // andl $2139062143, %eax + LONG $0xc0c0bb41; WORD $0xc0c0 // movl $-1061109568, %r11d + WORD $0x2941; BYTE $0xc3 // subl %eax, %r11d + LONG $0x46888d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rax), %r9d + WORD $0x2141; BYTE $0xcb // andl %ecx, %r11d + WORD $0x8545; BYTE $0xcb // testl %r9d, %r11d + LONG $0x04e0850f; WORD $0x0000 // jne LBB9_43, $1248(%rip) + LONG $0xe0e0b941; WORD $0xe0e0 // movl $-522133280, %r9d + WORD $0x2941; BYTE $0xc1 // subl %eax, %r9d + LONG $0x39393905; BYTE $0x39 // addl $960051513, %eax + WORD $0x2144; BYTE $0xc9 // andl %r9d, %ecx + WORD $0xc185 // testl %eax, %ecx + LONG $0x04c7850f; WORD $0x0000 // jne LBB9_43, $1223(%rip) + WORD $0xcb0f // bswapl %ebx + WORD $0xd989 // movl %ebx, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + LONG $0x0101e181; WORD $0x0101 // andl $16843009, %ecx + WORD $0x0c8d; BYTE $0xc9 // leal (%rcx,%rcx,8), %ecx + LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx + WORD $0xcb01 // addl %ecx, %ebx + WORD $0xd989 // movl %ebx, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xd909 // orl %ebx, %ecx + WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx + LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx + WORD $0xcb09 // orl %ecx, %ebx + LONG $0x044f8d4d // leaq $4(%r15), %r9 + LONG $0xfc4d8d49 // leaq $-4(%r13), %rcx + LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx + LONG $0x01e3820f; WORD $0x0000 // jb LBB9_54, $483(%rip) + LONG $0x02c0f641 // testb $2, %r8b + LONG $0x01ea840f; WORD $0x0000 // je LBB9_65, $490(%rip) + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + +LBB9_59: + LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d + LONG $0x02e3860f; WORD $0x0000 // jbe LBB9_67, $739(%rip) + QUAD $0xffff200024848d41 // leal $-57344(%r12), %eax + LONG $0xfff7ff3d; BYTE $0xff // cmpl $-2049, %eax + LONG $0x01f6860f; WORD $0x0000 // jbe LBB9_70, $502(%rip) + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xc07d8948 // movq %rdi, $-64(%rbp) + LONG $0xb0758948 // movq %rsi, $-80(%rbp) + LONG $0x00d2850f; WORD $0x0000 // jne LBB9_62, $210(%rip) + LONG $0xa855894c // movq %r10, $-88(%rbp) + LONG $0xa0558948 // movq %rdx, $-96(%rbp) + LONG $0x06fd8349 // cmpq $6, %r13 + LONG $0x00eb8c0f; WORD $0x0000 // jl LBB9_94, $235(%rip) + +LBB9_91: + LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d + LONG $0x00de870f; WORD $0x0000 // ja LBB9_94, $222(%rip) + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x00d4850f; WORD $0x0000 // jne LBB9_94, $212(%rip) + LONG $0x017f8041; BYTE $0x75 // cmpb $117, $1(%r15) + LONG $0x00c9850f; WORD $0x0000 // jne LBB9_94, $201(%rip) + LONG $0x025f8b41 // movl $2(%r15), %ebx + WORD $0xdf89 // movl %ebx, %edi + LONG $0x000636e8; BYTE $0x00 // callq _unhex16_is, $1590(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x052a840f; WORD $0x0000 // je LBB9_100, $1322(%rip) + WORD $0xcb0f // bswapl %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx + WORD $0xc301 // addl %eax, %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xd809 // orl %ebx, %eax + WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx + WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax + LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax + WORD $0x1c8d; BYTE $0x08 // leal (%rax,%rcx), %ebx + LONG $0x06c78349 // addq $6, %r15 + LONG $0xfac58349 // addq $-6, %r13 + WORD $0xc801 // addl %ecx, %eax + LONG $0xff200005; BYTE $0xff // addl $-57344, %eax + LONG $0xfffbff3d; BYTE $0xff // cmpl $-1025, %eax + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + LONG $0xa0558b48 // movq $-96(%rbp), %rdx + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + QUAD $0xfffffcd80d6ff9c5 // vmovdqa $-808(%rip), %xmm1 /* LCPI9_1(%rip) */ + QUAD $0xfffffcc0156ff9c5 // vmovdqa $-832(%rip), %xmm2 /* LCPI9_0(%rip) */ + LONG $0x017c870f; WORD $0x0000 // ja LBB9_110, $380(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx + LONG $0xa8558b4c // movq $-88(%rbp), %r10 + LONG $0xff02830f; WORD $0xffff // jae LBB9_59, $-254(%rip) + LONG $0x0000d3e9; BYTE $0x00 // jmp LBB9_55, $211(%rip) + +LBB9_62: + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x04718e0f; WORD $0x0000 // jle LBB9_63, $1137(%rip) + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x02bf850f; WORD $0x0000 // jne LBB9_96, $703(%rip) + WORD $0xff49; BYTE $0xcd // decq %r13 + WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0xa855894c // movq %r10, $-88(%rbp) + LONG $0xa0558948 // movq %rdx, $-96(%rbp) + LONG $0x06fd8349 // cmpq $6, %r13 + LONG $0xff158d0f; WORD $0xffff // jge LBB9_91, $-235(%rip) + +LBB9_94: + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x02f9840f; WORD $0x0000 // je LBB9_77, $761(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + LONG $0xa0558b48 // movq $-96(%rbp), %rdx + LONG $0xa8558b4c // movq $-88(%rbp), %r10 + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + LONG $0xb8458b4c // movq $-72(%rbp), %r8 + LONG $0x54258d4c; WORD $0x00e2; BYTE $0x00 // leaq $57940(%rip), %r12 /* __UnquoteTab(%rip) */ + QUAD $0xfffffc3c0d6ff9c5 // vmovdqa $-964(%rip), %xmm1 /* LCPI9_1(%rip) */ + QUAD $0xfffffc24156ff9c5 // vmovdqa $-988(%rip), %xmm2 /* LCPI9_0(%rip) */ + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfc84850f; WORD $0xffff // jne LBB9_4, $-892(%rip) + LONG $0x0003b8e9; BYTE $0x00 // jmp LBB9_37, $952(%rip) + +LBB9_21: + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x039c840f; WORD $0x0000 // je LBB9_19, $924(%rip) + LONG $0xff7f8041; BYTE $0x5c // cmpb $92, $-1(%r15) + LONG $0x03c5850f; WORD $0x0000 // jne LBB9_23, $965(%rip) + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x0027850f; WORD $0x0000 // jne LBB9_31, $39(%rip) + LONG $0x01fd8341 // cmpl $1, %r13d + LONG $0x037d8e0f; WORD $0x0000 // jle LBB9_19, $893(%rip) + LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx + WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx + LONG $0x0009840f; WORD $0x0000 // je LBB9_30, $9(%rip) + WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx + LONG $0x03b3850f; WORD $0x0000 // jne LBB9_29, $947(%rip) + +LBB9_30: + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xff49; BYTE $0xcd // decq %r13 + +LBB9_31: + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xff49; BYTE $0xcd // decq %r13 + LONG $0xfffd23e9; BYTE $0xff // jmp LBB9_32, $-733(%rip) + +LBB9_54: + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + +LBB9_55: + WORD $0x8841; BYTE $0x1e // movb %bl, (%r14) + WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0x00005ee9; BYTE $0x00 // jmp LBB9_56, $94(%rip) + +LBB9_65: + LONG $0x0800fb81; WORD $0x0000 // cmpl $2048, %ebx + LONG $0x00fa820f; WORD $0x0000 // jb LBB9_66, $250(%rip) + LONG $0x2000838d; WORD $0xffff // leal $-57344(%rbx), %eax + LONG $0xfff8003d; BYTE $0xff // cmpl $-2048, %eax + LONG $0x0112830f; WORD $0x0000 // jae LBB9_71, $274(%rip) + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_70: + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + WORD $0xe8c1; BYTE $0x0c // shrl $12, %eax + WORD $0xe00c // orb $-32, %al + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x01468841 // movb %al, $1(%r14) + LONG $0x3fe48041 // andb $63, %r12b + LONG $0x80cc8041 // orb $-128, %r12b + LONG $0x02668845 // movb %r12b, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + +LBB9_56: + LONG $0xb8458b4c // movq $-72(%rbp), %r8 + LONG $0x6c258d4c; WORD $0x00e1; BYTE $0x00 // leaq $57708(%rip), %r12 /* __UnquoteTab(%rip) */ + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfbac850f; WORD $0xffff // jne LBB9_4, $-1108(%rip) + LONG $0x0002e0e9; BYTE $0x00 // jmp LBB9_37, $736(%rip) + +LBB9_110: + WORD $0xd889 // movl %ebx, %eax + +LBB9_85: + LONG $0x0ae4c141 // shll $10, %r12d + WORD $0xc189 // movl %eax, %ecx + WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx + WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax + LONG $0xa0240005; BYTE $0xfc // addl $-56613888, %eax + WORD $0xc289 // movl %eax, %edx + WORD $0xeac1; BYTE $0x12 // shrl $18, %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xeec1; BYTE $0x0c // shrl $12, %esi + LONG $0x3fe68040 // andb $63, %sil + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + LONG $0xc26ef9c5 // vmovd %edx, %xmm0 + LONG $0xd6b60f40 // movzbl %sil, %edx + LONG $0x2079e3c4; WORD $0x01c2 // vpinsrb $1, %edx, %xmm0, %xmm0 + WORD $0x3f24 // andb $63, %al + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + LONG $0x2079e3c4; WORD $0x02c0 // vpinsrb $2, %eax, %xmm0, %xmm0 + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax + LONG $0x2079e3c4; WORD $0x03c0 // vpinsrb $3, %eax, %xmm0, %xmm0 + QUAD $0xfffffafd0d6ff9c5 // vmovdqa $-1283(%rip), %xmm1 /* LCPI9_1(%rip) */ + LONG $0xc1ebf9c5 // vpor %xmm1, %xmm0, %xmm0 + LONG $0x7e79c1c4; BYTE $0x06 // vmovd %xmm0, (%r14) + LONG $0x04c68349 // addq $4, %r14 + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + LONG $0xa0558b48 // movq $-96(%rbp), %rdx + LONG $0xa8558b4c // movq $-88(%rbp), %r10 + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + LONG $0xb8458b4c // movq $-72(%rbp), %r8 + LONG $0xe5258d4c; WORD $0x00e0; BYTE $0x00 // leaq $57573(%rip), %r12 /* __UnquoteTab(%rip) */ + QUAD $0xfffffabd156ff9c5 // vmovdqa $-1347(%rip), %xmm2 /* LCPI9_0(%rip) */ + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfb1d850f; WORD $0xffff // jne LBB9_4, $-1251(%rip) + LONG $0x000251e9; BYTE $0x00 // jmp LBB9_37, $593(%rip) + +LBB9_66: + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + +LBB9_67: + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0xc00c // orb $-64, %al + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + LONG $0x3fe48041 // andb $63, %r12b + LONG $0x80cc8041 // orb $-128, %r12b + LONG $0x01668845 // movb %r12b, $1(%r14) + LONG $0x02c68349 // addq $2, %r14 + LONG $0xffff2fe9; BYTE $0xff // jmp LBB9_56, $-209(%rip) + +LBB9_71: + WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 + LONG $0x984d8948 // movq %rcx, $-104(%rbp) + LONG $0xc84d894c // movq %r9, $-56(%rbp) + LONG $0xb0758948 // movq %rsi, $-80(%rbp) + LONG $0xa0558948 // movq %rdx, $-96(%rbp) + LONG $0xc07d8948 // movq %rdi, $-64(%rbp) + LONG $0xa855894c // movq %r10, $-88(%rbp) + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x00c7850f; WORD $0x0000 // jne LBB9_72, $199(%rip) + LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) + LONG $0x00ee820f; WORD $0x0000 // jb LBB9_76, $238(%rip) + +LBB9_78: + LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d + LONG $0x00e1870f; WORD $0x0000 // ja LBB9_76, $225(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) + LONG $0x00d4850f; WORD $0x0000 // jne LBB9_76, $212(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + LONG $0x75017880 // cmpb $117, $1(%rax) + LONG $0x00c6850f; WORD $0x0000 // jne LBB9_76, $198(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x588b; BYTE $0x02 // movl $2(%rax), %ebx + WORD $0xdf89 // movl %ebx, %edi + LONG $0x000331e8; BYTE $0x00 // callq _unhex16_is, $817(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x0221840f; WORD $0x0000 // je LBB9_82, $545(%rip) + WORD $0xcb0f // bswapl %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx + WORD $0xc301 // addl %eax, %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xd809 // orl %ebx, %eax + WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx + WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax + LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax + LONG $0xc8458348; BYTE $0x06 // addq $6, $-56(%rbp) + WORD $0x148d; BYTE $0x08 // leal (%rax,%rcx), %edx + LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx + LONG $0xfc00fa81; WORD $0xffff // cmpl $-1024, %edx + LONG $0x02ae820f; WORD $0x0000 // jb LBB9_98, $686(%rip) + WORD $0xc809 // orl %ecx, %eax + LONG $0x986d8b4c // movq $-104(%rbp), %r13 + LONG $0xfac58349 // addq $-6, %r13 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + LONG $0xfffe85e9; BYTE $0xff // jmp LBB9_85, $-379(%rip) + +LBB9_96: + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x028d840f; WORD $0x0000 // je LBB9_97, $653(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + LONG $0xfffe44e9; BYTE $0xff // jmp LBB9_56, $-444(%rip) + +LBB9_72: + LONG $0x05fd8349 // cmpq $5, %r13 + LONG $0x028a820f; WORD $0x0000 // jb LBB9_87, $650(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) + LONG $0x025e850f; WORD $0x0000 // jne LBB9_98, $606(%rip) + LONG $0xfbc58349 // addq $-5, %r13 + LONG $0x05c78349 // addq $5, %r15 + LONG $0x986d894c // movq %r13, $-104(%rbp) + LONG $0xc87d894c // movq %r15, $-56(%rbp) + LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) + LONG $0xff12830f; WORD $0xffff // jae LBB9_78, $-238(%rip) + +LBB9_76: + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + +LBB9_77: + LONG $0xa8458b48 // movq $-88(%rbp), %rax + LONG $0xc0450348 // addq $-64(%rbp), %rax + WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 + LONG $0xfcc78349 // addq $-4, %r15 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 + LONG $0x00000ce9; BYTE $0x00 // jmp LBB9_52, $12(%rip) + +LBB9_1: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + +LBB9_2: + WORD $0x014d; BYTE $0xee // addq %r13, %r14 + WORD $0x2949; BYTE $0xd6 // subq %rdx, %r14 + +LBB9_52: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + LONG $0x48c48348 // addq $72, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB9_43: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + LONG $0xd0758b48 // movq $-48(%rbp), %rsi + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0x0fb60f41 // movzbl (%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_45, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xffbb820f; WORD $0xffff // jb LBB9_52, $-69(%rip) + +LBB9_45: + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_47, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xff94820f; WORD $0xffff // jb LBB9_52, $-108(%rip) + +LBB9_47: + LONG $0x02488d48 // leaq $2(%rax), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_49, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xff6d820f; WORD $0xffff // jb LBB9_52, $-147(%rip) + +LBB9_49: + LONG $0x03488d48 // leaq $3(%rax), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_51, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xff46820f; WORD $0xffff // jb LBB9_52, $-186(%rip) + +LBB9_51: + LONG $0x04c08348 // addq $4, %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xffff3ae9; BYTE $0xff // jmp LBB9_52, $-198(%rip) + +LBB9_19: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + LONG $0xffff27e9; BYTE $0xff // jmp LBB9_52, $-217(%rip) + +LBB9_37: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + LONG $0xffff19e9; BYTE $0xff // jmp LBB9_2, $-231(%rip) + +LBB9_34: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0149; BYTE $0xff // addq %rdi, %r15 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + LONG $0xfdc6c749; WORD $0xffff; BYTE $0xff // movq $-3, %r14 + LONG $0xffff06e9; BYTE $0xff // jmp LBB9_52, $-250(%rip) + +LBB9_23: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0149; BYTE $0xff // addq %rdi, %r15 + +LBB9_24: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + LONG $0xfffeede9; BYTE $0xff // jmp LBB9_52, $-275(%rip) + +LBB9_29: + WORD $0x2949; BYTE $0xff // subq %rdi, %r15 + WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB9_24, $-30(%rip) + +LBB9_63: + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x0108840f; WORD $0x0000 // je LBB9_87, $264(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + LONG $0xfffebbe9; BYTE $0xff // jmp LBB9_2, $-325(%rip) + +LBB9_82: + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + +LBB9_100: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0xc0452b48 // subq $-64(%rbp), %rax + LONG $0x02c08348 // addq $2, %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_102, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe84820f; WORD $0xffff // jb LBB9_52, $-380(%rip) + +LBB9_102: + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_104, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe59820f; WORD $0xffff // jb LBB9_52, $-423(%rip) + +LBB9_104: + LONG $0x02488d48 // leaq $2(%rax), %rcx + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x4fb60f41; BYTE $0x04 // movzbl $4(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_106, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe2e820f; WORD $0xffff // jb LBB9_52, $-466(%rip) + +LBB9_106: + LONG $0x03488d48 // leaq $3(%rax), %rcx + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x4fb60f41; BYTE $0x05 // movzbl $5(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_108, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe03820f; WORD $0xffff // jb LBB9_52, $-509(%rip) + +LBB9_108: + LONG $0x04c08348 // addq $4, %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xfffdf3e9; BYTE $0xff // jmp LBB9_52, $-525(%rip) + +LBB9_97: + LONG $0xc87d894c // movq %r15, $-56(%rbp) + +LBB9_98: + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0xc0652b4c // subq $-64(%rbp), %r12 + LONG $0xfcc48349 // addq $-4, %r12 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x20 // movq %r12, (%rax) + LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 + LONG $0xfffdd0e9; BYTE $0xff // jmp LBB9_52, $-560(%rip) + +LBB9_87: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + LONG $0xb04d8b48 // movq $-80(%rbp), %rcx + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + LONG $0xfffdb9e9; BYTE $0xff // jmp LBB9_52, $-583(%rip) + + // .p2align 4, 0x90 +_unhex16_is: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0xf889 // movl %edi, %eax + WORD $0xd0f7 // notl %eax + LONG $0xcfd08f8d; WORD $0xcfcf // leal $-808464432(%rdi), %ecx + LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax + WORD $0xc885 // testl %ecx, %eax + LONG $0x0007840f; WORD $0x0000 // je LBB10_2, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB10_2: + LONG $0x19198f8d; WORD $0x1919 // leal $421075225(%rdi), %ecx + WORD $0xf909 // orl %edi, %ecx + LONG $0x8080c1f7; WORD $0x8080 // testl $-2139062144, %ecx + LONG $0x0007840f; WORD $0x0000 // je LBB10_4, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB10_4: + LONG $0x7f7fe781; WORD $0x7f7f // andl $2139062143, %edi + LONG $0xc0c0c0b9; BYTE $0xc0 // movl $-1061109568, %ecx + WORD $0xf929 // subl %edi, %ecx + LONG $0x4646978d; WORD $0x4646 // leal $1179010630(%rdi), %edx + WORD $0xc121 // andl %eax, %ecx + WORD $0xd185 // testl %edx, %ecx + LONG $0x0007840f; WORD $0x0000 // je LBB10_6, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB10_6: + LONG $0xe0e0e0b9; BYTE $0xe0 // movl $-522133280, %ecx + WORD $0xf929 // subl %edi, %ecx + LONG $0x3939c781; WORD $0x3939 // addl $960051513, %edi + WORD $0xc821 // andl %ecx, %eax + WORD $0xf885 // testl %edi, %eax + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI11_0: + QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&' + +LCPI11_1: + QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2' + +LCPI11_2: + QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd' + +LCPI11_3: + QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<' + + // .p2align 4, 0x90 +_html_escape: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x10ec8348 // subq $16, %rsp + LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + LONG $0xd0558948 // movq %rdx, $-48(%rbp) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x04a18e0f; WORD $0x0000 // jle LBB11_70, $1185(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8b4c; BYTE $0x08 // movq (%rax), %r9 + QUAD $0xffffff89056ff9c5 // vmovdqa $-119(%rip), %xmm0 /* LCPI11_0(%rip) */ + QUAD $0xffffff910d6ff9c5 // vmovdqa $-111(%rip), %xmm1 /* LCPI11_1(%rip) */ + QUAD $0xffffff99156ff9c5 // vmovdqa $-103(%rip), %xmm2 /* LCPI11_2(%rip) */ + QUAD $0xffffffa11d6ff9c5 // vmovdqa $-95(%rip), %xmm3 /* LCPI11_3(%rip) */ + LONG $0xfa1d8d4c; WORD $0x00dc; BYTE $0x00 // leaq $56570(%rip), %r11 /* __HtmlQuoteTab(%rip) */ + WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 + LONG $0xd0758b4c // movq $-48(%rbp), %r14 + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_2: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x047e8e0f; WORD $0x0000 // jle LBB11_3, $1150(%rip) + LONG $0x10fe8348 // cmpq $16, %rsi + WORD $0x930f; BYTE $0xc0 // setae %al + WORD $0x894d; BYTE $0xcd // movq %r9, %r13 + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x894d; BYTE $0xe7 // movq %r12, %r15 + LONG $0x10f98349 // cmpq $16, %r9 + LONG $0x007a820f; WORD $0x0000 // jb LBB11_12, $122(%rip) + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0x0070820f; WORD $0x0000 // jb LBB11_12, $112(%rip) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_7: + LONG $0x6f7a81c4; WORD $0x0424 // vmovdqu (%r12,%r8), %xmm4 + LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 + LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 + LONG $0xedebc9c5 // vpor %xmm5, %xmm6, %xmm5 + LONG $0xf2dbd9c5 // vpand %xmm2, %xmm4, %xmm6 + LONG $0xf374c9c5 // vpcmpeqb %xmm3, %xmm6, %xmm6 + LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 + LONG $0x7f7a81c4; WORD $0x0624 // vmovdqu %xmm4, (%r14,%r8) + LONG $0xc5d7f9c5 // vpmovmskb %xmm5, %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x0150850f; WORD $0x0000 // jne LBB11_8, $336(%rip) + LONG $0xf05a8d48 // leaq $-16(%rdx), %rbx + LONG $0xf0698d4c // leaq $-16(%rcx), %r13 + LONG $0x10c08349 // addq $16, %r8 + LONG $0x20fa8348 // cmpq $32, %rdx + WORD $0x9d0f; BYTE $0xc0 // setge %al + LONG $0x00108c0f; WORD $0x0000 // jl LBB11_11, $16(%rip) + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx + LONG $0x1ff98348 // cmpq $31, %rcx + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + LONG $0xffa78f0f; WORD $0xffff // jg LBB11_7, $-89(%rip) + +LBB11_11: + LONG $0x043c8d4f // leaq (%r12,%r8), %r15 + WORD $0x014d; BYTE $0xf0 // addq %r14, %r8 + +LBB11_12: + WORD $0xc084 // testb %al, %al + LONG $0x0068840f; WORD $0x0000 // je LBB11_13, $104(%rip) + LONG $0x6f7ac1c4; BYTE $0x27 // vmovdqu (%r15), %xmm4 + LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 + LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 + LONG $0xedebc9c5 // vpor %xmm5, %xmm6, %xmm5 + LONG $0xf2dbd9c5 // vpand %xmm2, %xmm4, %xmm6 + LONG $0xf374c9c5 // vpcmpeqb %xmm3, %xmm6, %xmm6 + LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 + LONG $0xc5d7f9c5 // vpmovmskb %xmm5, %eax + LONG $0x0100000d; BYTE $0x00 // orl $65536, %eax + LONG $0xd0bc0f44 // bsfl %eax, %r10d + LONG $0x7ef9e1c4; BYTE $0xe0 // vmovq %xmm4, %rax + WORD $0x394d; BYTE $0xd5 // cmpq %r10, %r13 + LONG $0x00f98d0f; WORD $0x0000 // jge LBB11_24, $249(%rip) + LONG $0x08fd8349 // cmpq $8, %r13 + LONG $0x0132820f; WORD $0x0000 // jb LBB11_35, $306(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0x08578d4d // leaq $8(%r15), %r10 + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf85d8d49 // leaq $-8(%r13), %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x01298d0f; WORD $0x0000 // jge LBB11_38, $297(%rip) + LONG $0x000136e9; BYTE $0x00 // jmp LBB11_39, $310(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB11_13: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00878e0f; WORD $0x0000 // jle LBB11_21, $135(%rip) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x007e8e0f; WORD $0x0000 // jle LBB11_21, $126(%rip) + WORD $0xd231 // xorl %edx, %edx + WORD $0xc031 // xorl %eax, %eax + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB11_16: + LONG $0x1cb60f45; BYTE $0x17 // movzbl (%r15,%rdx), %r11d + LONG $0x3efb8349 // cmpq $62, %r11 + LONG $0x0014870f; WORD $0x0000 // ja LBB11_17, $20(%rip) + QUAD $0x004000000000b948; WORD $0x5000 // movabsq $5764607797912141824, %rcx + LONG $0xd9a30f4c // btq %r11, %rcx + LONG $0x00ae820f; WORD $0x0000 // jb LBB11_45, $174(%rip) + +LBB11_17: + LONG $0xe2fb8141; WORD $0x0000; BYTE $0x00 // cmpl $226, %r11d + LONG $0x00a1840f; WORD $0x0000 // je LBB11_45, $161(%rip) + LONG $0x03148d4c // leaq (%rbx,%rax), %r10 + LONG $0x101c8845 // movb %r11b, (%r8,%rdx) + LONG $0xff488d48 // leaq $-1(%rax), %rcx + LONG $0x02fa8349 // cmpq $2, %r10 + LONG $0x00138c0f; WORD $0x0000 // jl LBB11_20, $19(%rip) + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0x01f88348 // cmpq $1, %rax + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xffa78f0f; WORD $0xffff // jg LBB11_16, $-89(%rip) + +LBB11_20: + WORD $0x2949; BYTE $0xcf // subq %rcx, %r15 + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0x5a1d8d4c; WORD $0x00db; BYTE $0x00 // leaq $56154(%rip), %r11 /* __HtmlQuoteTab(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB11_21: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0160840f; WORD $0x0000 // je LBB11_22, $352(%rip) + WORD $0xf749; BYTE $0xd7 // notq %r15 + WORD $0x014d; BYTE $0xe7 // addq %r12, %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0168890f; WORD $0x0000 // jns LBB11_49, $360(%rip) + LONG $0x000287e9; BYTE $0x00 // jmp LBB11_48, $647(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_8: + LONG $0xc0bc0f66 // bsfw %ax, %ax + LONG $0xf8b70f44 // movzwl %ax, %r15d + WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x014c890f; WORD $0x0000 // jns LBB11_49, $332(%rip) + LONG $0x00026be9; BYTE $0x00 // jmp LBB11_48, $619(%rip) + +LBB11_24: + LONG $0x08fa8341 // cmpl $8, %r10d + LONG $0x008f820f; WORD $0x0000 // jb LBB11_25, $143(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0x086f8d4d // leaq $8(%r15), %r13 + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf85a8d49 // leaq $-8(%r10), %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x0086830f; WORD $0x0000 // jae LBB11_28, $134(%rip) + LONG $0x000094e9; BYTE $0x00 // jmp LBB11_29, $148(%rip) + +LBB11_45: + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 + LONG $0xe21d8d4c; WORD $0x00da; BYTE $0x00 // leaq $56034(%rip), %r11 /* __HtmlQuoteTab(%rip) */ + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0109890f; WORD $0x0000 // jns LBB11_49, $265(%rip) + LONG $0x000228e9; BYTE $0x00 // jmp LBB11_48, $552(%rip) + +LBB11_35: + WORD $0x894d; BYTE $0xfa // movq %r15, %r10 + WORD $0x894c; BYTE $0xeb // movq %r13, %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x00128c0f; WORD $0x0000 // jl LBB11_39, $18(%rip) + +LBB11_38: + WORD $0x8b41; BYTE $0x02 // movl (%r10), %eax + WORD $0x8941; BYTE $0x00 // movl %eax, (%r8) + LONG $0x04c28349 // addq $4, %r10 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc38348 // addq $-4, %rbx + +LBB11_39: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x007c830f; WORD $0x0000 // jae LBB11_40, $124(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0007840f; WORD $0x0000 // je LBB11_43, $7(%rip) + +LBB11_42: + LONG $0x02b60f41 // movzbl (%r10), %eax + WORD $0x8841; BYTE $0x00 // movb %al, (%r8) + +LBB11_43: + WORD $0x014d; BYTE $0xfd // addq %r15, %r13 + WORD $0xf749; BYTE $0xd5 // notq %r13 + WORD $0x014d; BYTE $0xe5 // addq %r12, %r13 + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x00b3890f; WORD $0x0000 // jns LBB11_49, $179(%rip) + LONG $0x0001d2e9; BYTE $0x00 // jmp LBB11_48, $466(%rip) + +LBB11_25: + WORD $0x894d; BYTE $0xfd // movq %r15, %r13 + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x0013820f; WORD $0x0000 // jb LBB11_29, $19(%rip) + +LBB11_28: + LONG $0x00458b41 // movl (%r13), %eax + WORD $0x8941; BYTE $0x00 // movl %eax, (%r8) + LONG $0x04c58349 // addq $4, %r13 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc38348 // addq $-4, %rbx + +LBB11_29: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0047830f; WORD $0x0000 // jae LBB11_30, $71(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0008840f; WORD $0x0000 // je LBB11_33, $8(%rip) + +LBB11_32: + LONG $0x45b60f41; BYTE $0x00 // movzbl (%r13), %eax + WORD $0x8841; BYTE $0x00 // movb %al, (%r8) + +LBB11_33: + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + WORD $0x014d; BYTE $0xd7 // addq %r10, %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0061890f; WORD $0x0000 // jns LBB11_49, $97(%rip) + LONG $0x000180e9; BYTE $0x00 // jmp LBB11_48, $384(%rip) + +LBB11_40: + LONG $0x02b70f41 // movzwl (%r10), %eax + LONG $0x00894166 // movw %ax, (%r8) + LONG $0x02c28349 // addq $2, %r10 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xff70850f; WORD $0xffff // jne LBB11_42, $-144(%rip) + LONG $0xffff72e9; BYTE $0xff // jmp LBB11_43, $-142(%rip) + +LBB11_30: + LONG $0x45b70f41; BYTE $0x00 // movzwl (%r13), %eax + LONG $0x00894166 // movw %ax, (%r8) + LONG $0x02c58349 // addq $2, %r13 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xffa4850f; WORD $0xffff // jne LBB11_32, $-92(%rip) + LONG $0xffffa7e9; BYTE $0xff // jmp LBB11_33, $-89(%rip) + +LBB11_22: + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x012f880f; WORD $0x0000 // js LBB11_48, $303(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_49: + WORD $0x014d; BYTE $0xfc // addq %r15, %r12 + WORD $0x014d; BYTE $0xfe // addq %r15, %r14 + WORD $0x294c; BYTE $0xfe // subq %r15, %rsi + LONG $0x01378e0f; WORD $0x0000 // jle LBB11_50, $311(%rip) + WORD $0x294d; BYTE $0xf9 // subq %r15, %r9 + LONG $0x0cb60f41; BYTE $0x24 // movzbl (%r12), %ecx + WORD $0xf980; BYTE $0xe2 // cmpb $-30, %cl + LONG $0x00b3840f; WORD $0x0000 // je LBB11_53, $179(%rip) + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + +LBB11_57: + WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x19148b4a // movq (%rcx,%r11), %rdx + WORD $0x6348; BYTE $0xda // movslq %edx, %rbx + WORD $0x2949; BYTE $0xd9 // subq %rbx, %r9 + LONG $0x01228c0f; WORD $0x0000 // jl LBB11_58, $290(%rip) + LONG $0x20e2c148 // shlq $32, %rdx + LONG $0x19148d4e // leaq (%rcx,%r11), %r10 + LONG $0x08c28349 // addq $8, %r10 + QUAD $0x000300000001b948; WORD $0x0000 // movabsq $12884901889, %rcx + WORD $0x3948; BYTE $0xca // cmpq %rcx, %rdx + LONG $0x00278c0f; WORD $0x0000 // jl LBB11_62, $39(%rip) + WORD $0x8b41; BYTE $0x0a // movl (%r10), %ecx + WORD $0x8941; BYTE $0x0e // movl %ecx, (%r14) + LONG $0x04c28349 // addq $4, %r10 + LONG $0x04468d4d // leaq $4(%r14), %r8 + LONG $0xfc4b8d48 // leaq $-4(%rbx), %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x001b830f; WORD $0x0000 // jae LBB11_65, $27(%rip) + LONG $0x00002ae9; BYTE $0x00 // jmp LBB11_66, $42(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB11_62: + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x0014820f; WORD $0x0000 // jb LBB11_66, $20(%rip) + +LBB11_65: + LONG $0x12b70f41 // movzwl (%r10), %edx + LONG $0x10894166 // movw %dx, (%r8) + LONG $0x02c28349 // addq $2, %r10 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec18348 // addq $-2, %rcx + +LBB11_66: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0007840f; WORD $0x0000 // je LBB11_68, $7(%rip) + LONG $0x0ab60f41 // movzbl (%r10), %ecx + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + +LBB11_68: + WORD $0x0149; BYTE $0xde // addq %rbx, %r14 + +LBB11_69: + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx + WORD $0x8949; BYTE $0xc4 // movq %rax, %r12 + LONG $0x01fe8348 // cmpq $1, %rsi + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0xfc12870f; WORD $0xffff // ja LBB11_2, $-1006(%rip) + LONG $0x000076e9; BYTE $0x00 // jmp LBB11_70, $118(%rip) + +LBB11_53: + LONG $0x03fe8348 // cmpq $3, %rsi + LONG $0x002c820f; WORD $0x0000 // jb LBB11_59, $44(%rip) + LONG $0x247c8041; WORD $0x8001 // cmpb $-128, $1(%r12) + LONG $0x0020850f; WORD $0x0000 // jne LBB11_59, $32(%rip) + LONG $0x4cb60f41; WORD $0x0224 // movzbl $2(%r12), %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xfe24 // andb $-2, %al + WORD $0xa83c // cmpb $-88, %al + LONG $0x000e850f; WORD $0x0000 // jne LBB11_59, $14(%rip) + LONG $0x24448d49; BYTE $0x02 // leaq $2(%r12), %rax + LONG $0xfec68348 // addq $-2, %rsi + LONG $0xffff1ae9; BYTE $0xff // jmp LBB11_57, $-230(%rip) + +LBB11_59: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x00558e0f; WORD $0x0000 // jle LBB11_3, $85(%rip) + LONG $0xe206c641 // movb $-30, (%r14) + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0xff49; BYTE $0xc9 // decq %r9 + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0xffff93e9; BYTE $0xff // jmp LBB11_69, $-109(%rip) + +LBB11_48: + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x014c; BYTE $0xf9 // addq %r15, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + WORD $0x294c; BYTE $0xe7 // subq %r12, %rdi + WORD $0x014c; BYTE $0xff // addq %r15, %rdi + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x00002ae9; BYTE $0x00 // jmp LBB11_71, $42(%rip) + +LBB11_50: + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + +LBB11_70: + LONG $0xd0752b4c // subq $-48(%rbp), %r14 + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x894c; BYTE $0x31 // movq %r14, (%rcx) + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + LONG $0x000014e9; BYTE $0x00 // jmp LBB11_71, $20(%rip) + +LBB11_58: + LONG $0xd0752b4c // subq $-48(%rbp), %r14 + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x30 // movq %r14, (%rax) + +LBB11_3: + WORD $0xf749; BYTE $0xd4 // notq %r12 + WORD $0x0149; BYTE $0xfc // addq %rdi, %r12 + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + +LBB11_71: + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + BYTE $0x90 // .p2align 4, 0x90 + +_atof_eisel_lemire64: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0xfea4868d; WORD $0xffff // leal $-348(%rsi), %eax + LONG $0xfffd483d; BYTE $0xff // cmpl $-696, %eax + LONG $0x0122820f; WORD $0x0000 // jb LBB12_1, $290(%rip) + WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 + WORD $0x8941; BYTE $0xd1 // movl %edx, %r9d + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x000d840f; WORD $0x0000 // je LBB12_4, $13(%rip) + LONG $0xd7bd0f4c // bsrq %rdi, %r10 + LONG $0x3ff28349 // xorq $63, %r10 + LONG $0x000006e9; BYTE $0x00 // jmp LBB12_5, $6(%rip) + +LBB12_4: + LONG $0x0040ba41; WORD $0x0000 // movl $64, %r10d + +LBB12_5: + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xd348; BYTE $0xe7 // shlq %cl, %rdi + LONG $0x015c8e8d; WORD $0x0000 // leal $348(%rsi), %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x4b258d4c; WORD $0x0062; BYTE $0x00 // leaq $25163(%rip), %r12 /* _POW10_M128_TAB(%rip) */ + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x2164f74a; BYTE $0x08 // mulq $8(%rcx,%r12) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x8949; BYTE $0xd3 // movq %rdx, %r11 + WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx + LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx + LONG $0xfffb8148; WORD $0x0001; BYTE $0x00 // cmpq $511, %rbx + LONG $0x0050850f; WORD $0x0000 // jne LBB12_11, $80(%rip) + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + WORD $0xf749; BYTE $0xd6 // notq %r14 + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0x394d; BYTE $0xf7 // cmpq %r14, %r15 + LONG $0x0041860f; WORD $0x0000 // jbe LBB12_13, $65(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x2124f74a // mulq (%rcx,%r12) + WORD $0x014c; BYTE $0xfa // addq %r15, %rdx + LONG $0x00d38349 // adcq $0, %r11 + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0x37e1c148 // shlq $55, %rcx + LONG $0x0013850f; WORD $0x0000 // jne LBB12_12, $19(%rip) + LONG $0xfffa8348 // cmpq $-1, %rdx + LONG $0x0009850f; WORD $0x0000 // jne LBB12_12, $9(%rip) + WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax + LONG $0x0083870f; WORD $0x0000 // ja LBB12_1, $131(%rip) + +LBB12_12: + WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx + LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx + LONG $0x000003e9; BYTE $0x00 // jmp LBB12_13, $3(%rip) + +LBB12_11: + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + +LBB12_13: + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + LONG $0x3fe8c148 // shrq $63, %rax + WORD $0x488d; BYTE $0x09 // leal $9(%rax), %ecx + WORD $0xd349; BYTE $0xeb // shrq %cl, %r11 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0018850f; WORD $0x0000 // jne LBB12_17, $24(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x000f850f; WORD $0x0000 // jne LBB12_17, $15(%rip) + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + WORD $0xe183; BYTE $0x03 // andl $3, %ecx + WORD $0xf983; BYTE $0x01 // cmpl $1, %ecx + LONG $0x0044840f; WORD $0x0000 // je LBB12_1, $68(%rip) + +LBB12_17: + LONG $0x526ace69; WORD $0x0003 // imull $217706, %esi, %ecx + WORD $0xf9c1; BYTE $0x10 // sarl $16, %ecx + LONG $0x043fc181; WORD $0x0000 // addl $1087, %ecx + WORD $0x6348; BYTE $0xf1 // movslq %ecx, %rsi + WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi + WORD $0x8944; BYTE $0xda // movl %r11d, %edx + WORD $0xe283; BYTE $0x01 // andl $1, %edx + WORD $0x014c; BYTE $0xda // addq %r11, %rdx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x36e9c148 // shrq $54, %rcx + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0x01f98348 // cmpq $1, %rcx + LONG $0x00d88348 // sbbq $0, %rax + LONG $0x01b08d48; WORD $0xfff8; BYTE $0xff // leaq $-2047(%rax), %rsi + LONG $0x02fe8148; WORD $0xfff8; BYTE $0xff // cmpq $-2046, %rsi + LONG $0x000b830f; WORD $0x0000 // jae LBB12_19, $11(%rip) + +LBB12_1: + WORD $0xc031 // xorl %eax, %eax + +LBB12_20: + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB12_19: + LONG $0x01f98348 // cmpq $1, %rcx + WORD $0x02b1 // movb $2, %cl + WORD $0xd980; BYTE $0x00 // sbbb $0, %cl + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + LONG $0x34e0c148 // shlq $52, %rax + QUAD $0xffffffffffffb948; WORD $0x000f // movabsq $4503599627370495, %rcx + WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xfff98341 // cmpl $-1, %r9d + LONG $0xc1450f48 // cmovneq %rcx, %rax + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + WORD $0x01b0 // movb $1, %al + LONG $0xffffb8e9; BYTE $0xff // jmp LBB12_20, $-72(%rip) + QUAD $0x0000000000000000 // .p2align 5, 0x00 + +LCPI13_0: + QUAD $0x0000000000000000 // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000001 // .quad 1 + +LCPI13_1: + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000001 // .quad 1 + + // .p2align 4, 0x00 +LCPI13_2: + QUAD $0x0000000000002710 // .quad 10000 + QUAD $0x0000000000002710 // .quad 10000 + +LCPI13_3: + QUAD $0x000000000000000a // .quad 10 + QUAD $0x000000000000000a // .quad 10 + + // .p2align 4, 0x90 +_decimal_to_f64: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 + LONG $0x00107f83 // cmpl $0, $16(%rdi) + LONG $0x0021840f; WORD $0x0000 // je LBB13_3, $33(%rip) + LONG $0x14478b41 // movl $20(%r15), %eax + LONG $0x0001363d; BYTE $0x00 // cmpl $310, %eax + LONG $0x001d8e0f; WORD $0x0000 // jle LBB13_4, $29(%rip) + +LBB13_2: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 + LONG $0x000706e9; BYTE $0x00 // jmp LBB13_74, $1798(%rip) + +LBB13_3: + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x0006fbe9; BYTE $0x00 // jmp LBB13_74, $1787(%rip) + +LBB13_4: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xfffeb63d; BYTE $0xff // cmpl $-330, %eax + LONG $0x00088d0f; WORD $0x0000 // jge LBB13_6, $8(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x0006e5e9; BYTE $0x00 // jmp LBB13_74, $1765(%rip) + +LBB13_6: + WORD $0xc085 // testl %eax, %eax + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x00aa8e0f; WORD $0x0000 // jle LBB13_17, $170(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xc0358d4c; WORD $0x008b; BYTE $0x00 // leaq $35776(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x000039e9; BYTE $0x00 // jmp LBB13_11, $57(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_8: + LONG $0xffffe5be; BYTE $0xff // movl $-27, %esi + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x000a840f; WORD $0x0000 // je LBB13_10, $10(%rip) + +LBB13_9: + WORD $0xdef7 // negl %esi + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x0057a1e8; BYTE $0x00 // callq _right_shift, $22433(%rip) + +LBB13_10: + WORD $0x0141; BYTE $0xdc // addl %ebx, %r12d + LONG $0x14478b41 // movl $20(%r15), %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x00628e0f; WORD $0x0000 // jle LBB13_17, $98(%rip) + +LBB13_11: + WORD $0xf883; BYTE $0x08 // cmpl $8, %eax + LONG $0xffc9870f; WORD $0xffff // ja LBB13_8, $-55(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0x861c8b41 // movl (%r14,%rax,4), %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xffd7840f; WORD $0xffff // je LBB13_10, $-41(%rip) + WORD $0xde89 // movl %ebx, %esi + WORD $0xdef7 // negl %esi + WORD $0xfe83; BYTE $0xc3 // cmpl $-61, %esi + LONG $0xffc0870f; WORD $0xffff // ja LBB13_9, $-64(%rip) + WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB13_15: + WORD $0x8941; BYTE $0xf6 // movl %esi, %r14d + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi + LONG $0x005750e8; BYTE $0x00 // callq _right_shift, $22352(%rip) + LONG $0x3c768d41 // leal $60(%r14), %esi + LONG $0x88fe8341 // cmpl $-120, %r14d + LONG $0xffe2820f; WORD $0xffff // jb LBB13_15, $-30(%rip) + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 + LONG $0xffff85e9; BYTE $0xff // jmp LBB13_9, $-123(%rip) + +LBB13_17: + LONG $0x19358d4c; WORD $0x008b; BYTE $0x00 // leaq $35609(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x000025e9; BYTE $0x00 // jmp LBB13_19, $37(%rip) + +LBB13_23: + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x0012840f; WORD $0x0000 // je LBB13_18, $18(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB13_25: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0xde89 // movl %ebx, %esi + LONG $0x005516e8; BYTE $0x00 // callq _left_shift, $21782(%rip) + LONG $0x14478b41 // movl $20(%r15), %eax + +LBB13_18: + WORD $0x2941; BYTE $0xdc // subl %ebx, %r12d + +LBB13_19: + WORD $0xc085 // testl %eax, %eax + LONG $0x0017880f; WORD $0x0000 // js LBB13_22, $23(%rip) + LONG $0x0032850f; WORD $0x0000 // jne LBB13_26, $50(%rip) + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + WORD $0x3980; BYTE $0x35 // cmpb $53, (%rcx) + LONG $0x000e8c0f; WORD $0x0000 // jl LBB13_24, $14(%rip) + LONG $0x000021e9; BYTE $0x00 // jmp LBB13_26, $33(%rip) + + // .p2align 4, 0x90 +LBB13_22: + WORD $0xf883; BYTE $0xf8 // cmpl $-8, %eax + LONG $0xffb3820f; WORD $0xffff // jb LBB13_23, $-77(%rip) + +LBB13_24: + WORD $0xc189 // movl %eax, %ecx + WORD $0xd9f7 // negl %ecx + LONG $0x8e1c8b41 // movl (%r14,%rcx,4), %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xffb4850f; WORD $0xffff // jne LBB13_25, $-76(%rip) + LONG $0xffffbde9; BYTE $0xff // jmp LBB13_18, $-67(%rip) + +LBB13_26: + LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff // cmpl $-1022, %r12d + LONG $0x00568f0f; WORD $0x0000 // jg LBB13_32, $86(%rip) + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x0075840f; WORD $0x0000 // je LBB13_35, $117(%rip) + LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff // cmpl $-1082, %r12d + LONG $0x0073870f; WORD $0x0000 // ja LBB13_36, $115(%rip) + LONG $0xc1c48141; WORD $0x0003; BYTE $0x00 // addl $961, %r12d + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_30: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi + LONG $0x005673e8; BYTE $0x00 // callq _right_shift, $22131(%rip) + LONG $0x3cc48341 // addl $60, %r12d + LONG $0x88fc8341 // cmpl $-120, %r12d + LONG $0xffe5820f; WORD $0xffff // jb LBB13_30, $-27(%rip) + LONG $0x3cc48341 // addl $60, %r12d + LONG $0x000040e9; BYTE $0x00 // jmp LBB13_37, $64(%rip) + +LBB13_32: + LONG $0x00fc8141; WORD $0x0004; BYTE $0x00 // cmpl $1024, %r12d + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 + LONG $0x00088e0f; WORD $0x0000 // jle LBB13_34, $8(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x000538e9; BYTE $0x00 // jmp LBB13_74, $1336(%rip) + +LBB13_34: + WORD $0xff41; BYTE $0xcc // decl %r12d + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + LONG $0x000026e9; BYTE $0x00 // jmp LBB13_38, $38(%rip) + +LBB13_35: + LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d + LONG $0x000033e9; BYTE $0x00 // jmp LBB13_40, $51(%rip) + +LBB13_36: + LONG $0xfdc48141; WORD $0x0003; BYTE $0x00 // addl $1021, %r12d + +LBB13_37: + WORD $0xf741; BYTE $0xdc // negl %r12d + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x8944; BYTE $0xe6 // movl %r12d, %esi + LONG $0x00560ee8; BYTE $0x00 // callq _right_shift, $22030(%rip) + LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d + +LBB13_38: + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x000d840f; WORD $0x0000 // je LBB13_40, $13(%rip) + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x000035be; BYTE $0x00 // movl $53, %esi + LONG $0x005400e8; BYTE $0x00 // callq _left_shift, $21504(%rip) + +LBB13_40: + LONG $0x14478b41 // movl $20(%r15), %eax + LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 + WORD $0xf883; BYTE $0x14 // cmpl $20, %eax + LONG $0x04bc8f0f; WORD $0x0000 // jg LBB13_73, $1212(%rip) + WORD $0xc085 // testl %eax, %eax + LONG $0x00558e0f; WORD $0x0000 // jle LBB13_46, $85(%rip) + LONG $0x10578b41 // movl $16(%r15), %edx + WORD $0xf631 // xorl %esi, %esi + WORD $0xd285 // testl %edx, %edx + WORD $0x4e0f; BYTE $0xd6 // cmovlel %esi, %edx + LONG $0xff488d4c // leaq $-1(%rax), %r9 + WORD $0x3949; BYTE $0xd1 // cmpq %rdx, %r9 + LONG $0xca430f4c // cmovaeq %rdx, %r9 + LONG $0x01418d4d // leaq $1(%r9), %r8 + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_43: + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x002e840f; WORD $0x0000 // je LBB13_47, $46(%rip) + LONG $0xa40c8d4b // leaq (%r12,%r12,4), %rcx + WORD $0x8b49; BYTE $0x3f // movq (%r15), %rdi + LONG $0x3cbe0f48; BYTE $0x37 // movsbq (%rdi,%rsi), %rdi + LONG $0x4f248d4c // leaq (%rdi,%rcx,2), %r12 + LONG $0xd0c48349 // addq $-48, %r12 + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffd7850f; WORD $0xffff // jne LBB13_43, $-41(%rip) + WORD $0x894d; BYTE $0xc1 // movq %r8, %r9 + LONG $0x000006e9; BYTE $0x00 // jmp LBB13_47, $6(%rip) + +LBB13_46: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + +LBB13_47: + WORD $0x3944; BYTE $0xc8 // cmpl %r9d, %eax + LONG $0x03cf8e0f; WORD $0x0000 // jle LBB13_60, $975(%rip) + WORD $0xc289 // movl %eax, %edx + WORD $0x2944; BYTE $0xca // subl %r9d, %edx + WORD $0xfa83; BYTE $0x10 // cmpl $16, %edx + LONG $0x03a0820f; WORD $0x0000 // jb LBB13_58, $928(%rip) + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + QUAD $0xfffffca7056ff9c5 // vmovdqa $-857(%rip), %xmm0 /* LCPI13_0(%rip) */ + LONG $0x22f9c3c4; WORD $0x00c4 // vpinsrq $0, %r12, %xmm0, %xmm0 + QUAD $0xfffc970d0c7de3c4; WORD $0xf0ff // vblendps $240, $-873(%rip), %ymm0, %ymm1 /* LCPI13_0(%rip) */ + LONG $0xf0e08341 // andl $-16, %r8d + LONG $0xf0488d41 // leal $-16(%r8), %ecx + WORD $0xcf89 // movl %ecx, %edi + WORD $0xefc1; BYTE $0x04 // shrl $4, %edi + WORD $0xc7ff // incl %edi + WORD $0xfe89 // movl %edi, %esi + WORD $0xe683; BYTE $0x03 // andl $3, %esi + WORD $0xf983; BYTE $0x30 // cmpl $48, %ecx + LONG $0x0015830f; WORD $0x0000 // jae LBB13_51, $21(%rip) + QUAD $0xfffffc92156ffdc5 // vmovdqa $-878(%rip), %ymm2 /* LCPI13_1(%rip) */ + LONG $0xda6ffdc5 // vmovdqa %ymm2, %ymm3 + LONG $0xc26ffdc5 // vmovdqa %ymm2, %ymm0 + LONG $0x00010ee9; BYTE $0x00 // jmp LBB13_53, $270(%rip) + +LBB13_51: + WORD $0xe783; BYTE $0xfc // andl $-4, %edi + QUAD $0xfffffc7a156ffdc5 // vmovdqa $-902(%rip), %ymm2 /* LCPI13_1(%rip) */ + QUAD $0xfffffc92256ff9c5 // vmovdqa $-878(%rip), %xmm4 /* LCPI13_2(%rip) */ + LONG $0xda6ffdc5 // vmovdqa %ymm2, %ymm3 + LONG $0xc26ffdc5 // vmovdqa %ymm2, %ymm0 + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB13_52: + LONG $0x197de3c4; WORD $0x01cd // vextractf128 $1, %ymm1, %xmm5 + LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 + LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 + LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 + LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 + LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 + LONG $0xf4f4f1c5 // vpmuludq %xmm4, %xmm1, %xmm6 + LONG $0xd173f1c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm1 + LONG $0xccf4f1c5 // vpmuludq %xmm4, %xmm1, %xmm1 + LONG $0xf173f1c5; BYTE $0x20 // vpsllq $32, %xmm1, %xmm1 + LONG $0xc9d4c9c5 // vpaddq %xmm1, %xmm6, %xmm1 + LONG $0x1875e3c4; WORD $0x01cd // vinsertf128 $1, %xmm5, %ymm1, %ymm1 + LONG $0x197de3c4; WORD $0x01d5 // vextractf128 $1, %ymm2, %xmm5 + LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 + LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 + LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 + LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 + LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 + LONG $0xf4f4e9c5 // vpmuludq %xmm4, %xmm2, %xmm6 + LONG $0xd273e9c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm2 + LONG $0xd4f4e9c5 // vpmuludq %xmm4, %xmm2, %xmm2 + LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 + LONG $0xd2d4c9c5 // vpaddq %xmm2, %xmm6, %xmm2 + LONG $0x186de3c4; WORD $0x01d5 // vinsertf128 $1, %xmm5, %ymm2, %ymm2 + LONG $0x197de3c4; WORD $0x01dd // vextractf128 $1, %ymm3, %xmm5 + LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 + LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 + LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 + LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 + LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 + LONG $0xf4f4e1c5 // vpmuludq %xmm4, %xmm3, %xmm6 + LONG $0xd373e1c5; BYTE $0x20 // vpsrlq $32, %xmm3, %xmm3 + LONG $0xdcf4e1c5 // vpmuludq %xmm4, %xmm3, %xmm3 + LONG $0xf373e1c5; BYTE $0x20 // vpsllq $32, %xmm3, %xmm3 + LONG $0xdbd4c9c5 // vpaddq %xmm3, %xmm6, %xmm3 + LONG $0x1865e3c4; WORD $0x01dd // vinsertf128 $1, %xmm5, %ymm3, %ymm3 + LONG $0x197de3c4; WORD $0x01c5 // vextractf128 $1, %ymm0, %xmm5 + LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 + LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 + LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 + LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 + LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 + LONG $0xf4f4f9c5 // vpmuludq %xmm4, %xmm0, %xmm6 + LONG $0xd073f9c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm0 + LONG $0xc4f4f9c5 // vpmuludq %xmm4, %xmm0, %xmm0 + LONG $0xf073f9c5; BYTE $0x20 // vpsllq $32, %xmm0, %xmm0 + LONG $0xc0d4c9c5 // vpaddq %xmm0, %xmm6, %xmm0 + LONG $0x187de3c4; WORD $0x01c5 // vinsertf128 $1, %xmm5, %ymm0, %ymm0 + WORD $0xc783; BYTE $0xfc // addl $-4, %edi + LONG $0xff17850f; WORD $0xffff // jne LBB13_52, $-233(%rip) + +LBB13_53: + WORD $0xf685 // testl %esi, %esi + LONG $0x00f7840f; WORD $0x0000 // je LBB13_56, $247(%rip) + QUAD $0xfffffb97256ff9c5 // vmovdqa $-1129(%rip), %xmm4 /* LCPI13_3(%rip) */ + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_55: + LONG $0x197de3c4; WORD $0x01cd // vextractf128 $1, %ymm1, %xmm5 + LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 + LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 + LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 + LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 + LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 + LONG $0xf4f4f1c5 // vpmuludq %xmm4, %xmm1, %xmm6 + LONG $0xd173f1c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm1 + LONG $0xccf4f1c5 // vpmuludq %xmm4, %xmm1, %xmm1 + LONG $0xf173f1c5; BYTE $0x20 // vpsllq $32, %xmm1, %xmm1 + LONG $0xc9d4c9c5 // vpaddq %xmm1, %xmm6, %xmm1 + LONG $0x1875e3c4; WORD $0x01cd // vinsertf128 $1, %xmm5, %ymm1, %ymm1 + LONG $0x197de3c4; WORD $0x01d5 // vextractf128 $1, %ymm2, %xmm5 + LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 + LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 + LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 + LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 + LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 + LONG $0xf4f4e9c5 // vpmuludq %xmm4, %xmm2, %xmm6 + LONG $0xd273e9c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm2 + LONG $0xd4f4e9c5 // vpmuludq %xmm4, %xmm2, %xmm2 + LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 + LONG $0xd2d4c9c5 // vpaddq %xmm2, %xmm6, %xmm2 + LONG $0x186de3c4; WORD $0x01d5 // vinsertf128 $1, %xmm5, %ymm2, %ymm2 + LONG $0x197de3c4; WORD $0x01dd // vextractf128 $1, %ymm3, %xmm5 + LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 + LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 + LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 + LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 + LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 + LONG $0xf4f4e1c5 // vpmuludq %xmm4, %xmm3, %xmm6 + LONG $0xd373e1c5; BYTE $0x20 // vpsrlq $32, %xmm3, %xmm3 + LONG $0xdcf4e1c5 // vpmuludq %xmm4, %xmm3, %xmm3 + LONG $0xf373e1c5; BYTE $0x20 // vpsllq $32, %xmm3, %xmm3 + LONG $0xdbd4c9c5 // vpaddq %xmm3, %xmm6, %xmm3 + LONG $0x1865e3c4; WORD $0x01dd // vinsertf128 $1, %xmm5, %ymm3, %ymm3 + LONG $0x197de3c4; WORD $0x01c5 // vextractf128 $1, %ymm0, %xmm5 + LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 + LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 + LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 + LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 + LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 + LONG $0xf4f4f9c5 // vpmuludq %xmm4, %xmm0, %xmm6 + LONG $0xd073f9c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm0 + LONG $0xc4f4f9c5 // vpmuludq %xmm4, %xmm0, %xmm0 + LONG $0xf073f9c5; BYTE $0x20 // vpsllq $32, %xmm0, %xmm0 + LONG $0xc0d4c9c5 // vpaddq %xmm0, %xmm6, %xmm0 + LONG $0x187de3c4; WORD $0x01c5 // vinsertf128 $1, %xmm5, %ymm0, %ymm0 + WORD $0xceff // decl %esi + LONG $0xff18850f; WORD $0xffff // jne LBB13_55, $-232(%rip) + +LBB13_56: + LONG $0x197de3c4; WORD $0x01cc // vextractf128 $1, %ymm1, %xmm4 + LONG $0x197de3c4; WORD $0x01d5 // vextractf128 $1, %ymm2, %xmm5 + LONG $0xd573c9c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm6 + LONG $0xf4f4c9c5 // vpmuludq %xmm4, %xmm6, %xmm6 + LONG $0xd473c1c5; BYTE $0x20 // vpsrlq $32, %xmm4, %xmm7 + LONG $0xfff4d1c5 // vpmuludq %xmm7, %xmm5, %xmm7 + LONG $0xf6d4c1c5 // vpaddq %xmm6, %xmm7, %xmm6 + LONG $0xf673c9c5; BYTE $0x20 // vpsllq $32, %xmm6, %xmm6 + LONG $0xe4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm4 + LONG $0xe6d4d9c5 // vpaddq %xmm6, %xmm4, %xmm4 + LONG $0xd273d1c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm5 + LONG $0xe9f4d1c5 // vpmuludq %xmm1, %xmm5, %xmm5 + LONG $0xd173c9c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm6 + LONG $0xf6f4e9c5 // vpmuludq %xmm6, %xmm2, %xmm6 + LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 + LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 + LONG $0xc9f4e9c5 // vpmuludq %xmm1, %xmm2, %xmm1 + LONG $0xcdd4f1c5 // vpaddq %xmm5, %xmm1, %xmm1 + LONG $0xd373e9c5; BYTE $0x20 // vpsrlq $32, %xmm3, %xmm2 + LONG $0xd1f4e9c5 // vpmuludq %xmm1, %xmm2, %xmm2 + LONG $0xd173d1c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm5 + LONG $0xedf4e1c5 // vpmuludq %xmm5, %xmm3, %xmm5 + LONG $0xd2d4d1c5 // vpaddq %xmm2, %xmm5, %xmm2 + LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 + LONG $0xc9f4e1c5 // vpmuludq %xmm1, %xmm3, %xmm1 + LONG $0xcad4f1c5 // vpaddq %xmm2, %xmm1, %xmm1 + LONG $0x197de3c4; WORD $0x01da // vextractf128 $1, %ymm3, %xmm2 + LONG $0xd273e1c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm3 + LONG $0xdcf4e1c5 // vpmuludq %xmm4, %xmm3, %xmm3 + LONG $0xd473d1c5; BYTE $0x20 // vpsrlq $32, %xmm4, %xmm5 + LONG $0xedf4e9c5 // vpmuludq %xmm5, %xmm2, %xmm5 + LONG $0xdbd4d1c5 // vpaddq %xmm3, %xmm5, %xmm3 + LONG $0xf373e1c5; BYTE $0x20 // vpsllq $32, %xmm3, %xmm3 + LONG $0xd4f4e9c5 // vpmuludq %xmm4, %xmm2, %xmm2 + LONG $0xd3d4e9c5 // vpaddq %xmm3, %xmm2, %xmm2 + LONG $0x197de3c4; WORD $0x01c3 // vextractf128 $1, %ymm0, %xmm3 + LONG $0xd373d9c5; BYTE $0x20 // vpsrlq $32, %xmm3, %xmm4 + LONG $0xe2f4d9c5 // vpmuludq %xmm2, %xmm4, %xmm4 + LONG $0xd273d1c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm5 + LONG $0xedf4e1c5 // vpmuludq %xmm5, %xmm3, %xmm5 + LONG $0xe4d4d1c5 // vpaddq %xmm4, %xmm5, %xmm4 + LONG $0xf473d9c5; BYTE $0x20 // vpsllq $32, %xmm4, %xmm4 + LONG $0xd2f4e1c5 // vpmuludq %xmm2, %xmm3, %xmm2 + LONG $0xd4d4e9c5 // vpaddq %xmm4, %xmm2, %xmm2 + LONG $0xd073e1c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm3 + LONG $0xd9f4e1c5 // vpmuludq %xmm1, %xmm3, %xmm3 + LONG $0xd173d9c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm4 + LONG $0xe4f4f9c5 // vpmuludq %xmm4, %xmm0, %xmm4 + LONG $0xdbd4d9c5 // vpaddq %xmm3, %xmm4, %xmm3 + LONG $0xf373e1c5; BYTE $0x20 // vpsllq $32, %xmm3, %xmm3 + LONG $0xc1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm0 + LONG $0xc3d4f9c5 // vpaddq %xmm3, %xmm0, %xmm0 + LONG $0xd073f1c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm1 + LONG $0xcaf4f1c5 // vpmuludq %xmm2, %xmm1, %xmm1 + LONG $0xd273e1c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm3 + LONG $0xdbf4f9c5 // vpmuludq %xmm3, %xmm0, %xmm3 + LONG $0xc9d4e1c5 // vpaddq %xmm1, %xmm3, %xmm1 + LONG $0xf173f1c5; BYTE $0x20 // vpsllq $32, %xmm1, %xmm1 + LONG $0xc2f4f9c5 // vpmuludq %xmm2, %xmm0, %xmm0 + LONG $0xc1d4f9c5 // vpaddq %xmm1, %xmm0, %xmm0 + LONG $0xc870f9c5; BYTE $0xee // vpshufd $238, %xmm0, %xmm1 + LONG $0xd073e9c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm2 + LONG $0xd1f4e9c5 // vpmuludq %xmm1, %xmm2, %xmm2 + LONG $0xd870f9c5; BYTE $0xff // vpshufd $255, %xmm0, %xmm3 + LONG $0xdbf4f9c5 // vpmuludq %xmm3, %xmm0, %xmm3 + LONG $0xd2d4e1c5 // vpaddq %xmm2, %xmm3, %xmm2 + LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 + LONG $0xc1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm0 + LONG $0xc2d4f9c5 // vpaddq %xmm2, %xmm0, %xmm0 + LONG $0x7ef9c1c4; BYTE $0xc4 // vmovq %xmm0, %r12 + WORD $0x3944; BYTE $0xc2 // cmpl %r8d, %edx + LONG $0x0024840f; WORD $0x0000 // je LBB13_60, $36(%rip) + WORD $0x0145; BYTE $0xc1 // addl %r8d, %r9d + +LBB13_58: + WORD $0xc289 // movl %eax, %edx + WORD $0x2944; BYTE $0xca // subl %r9d, %edx + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_59: + WORD $0x014d; BYTE $0xe4 // addq %r12, %r12 + LONG $0xa4248d4f // leaq (%r12,%r12,4), %r12 + WORD $0xcaff // decl %edx + LONG $0xfff1850f; WORD $0xffff // jne LBB13_59, $-15(%rip) + +LBB13_60: + WORD $0xc085 // testl %eax, %eax + LONG $0x004b880f; WORD $0x0000 // js LBB13_67, $75(%rip) + LONG $0x10578b41 // movl $16(%r15), %edx + WORD $0xc239 // cmpl %eax, %edx + LONG $0x003f8e0f; WORD $0x0000 // jle LBB13_67, $63(%rip) + WORD $0x8b49; BYTE $0x37 // movq (%r15), %rsi + LONG $0x060cb60f // movzbl (%rsi,%rax), %ecx + WORD $0xf980; BYTE $0x35 // cmpb $53, %cl + LONG $0x00b2850f; WORD $0x0000 // jne LBB13_69, $178(%rip) + WORD $0x788d; BYTE $0x01 // leal $1(%rax), %edi + WORD $0xd739 // cmpl %edx, %edi + LONG $0x00a7850f; WORD $0x0000 // jne LBB13_69, $167(%rip) + WORD $0x01b2 // movb $1, %dl + LONG $0x1c7f8341; BYTE $0x00 // cmpl $0, $28(%r15) + LONG $0x0019850f; WORD $0x0000 // jne LBB13_70, $25(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x000e840f; WORD $0x0000 // je LBB13_67, $14(%rip) + WORD $0xc8ff // decl %eax + LONG $0x0614b60f // movzbl (%rsi,%rax), %edx + WORD $0xe280; BYTE $0x01 // andb $1, %dl + LONG $0x000002e9; BYTE $0x00 // jmp LBB13_70, $2(%rip) + +LBB13_67: + WORD $0xd231 // xorl %edx, %edx + +LBB13_70: + WORD $0xb60f; BYTE $0xc2 // movzbl %dl, %eax + WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 + QUAD $0x000000000000b848; WORD $0x0020 // movabsq $9007199254740992, %rax + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0x0013850f; WORD $0x0000 // jne LBB13_73, $19(%rip) + LONG $0xfefe8141; WORD $0x0003; BYTE $0x00 // cmpl $1022, %r14d + LONG $0xf90d8f0f; WORD $0xffff // jg LBB13_2, $-1779(%rip) + WORD $0xff41; BYTE $0xc6 // incl %r14d + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + +LBB13_73: + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + WORD $0x214c; BYTE $0xe8 // andq %r13, %rax + LONG $0xffc68141; WORD $0x0003; BYTE $0x00 // addl $1023, %r14d + LONG $0xffe68141; WORD $0x0007; BYTE $0x00 // andl $2047, %r14d + LONG $0x34e6c149 // shlq $52, %r14 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xf0440f4c // cmoveq %rax, %r14 + +LBB13_74: + WORD $0xff49; BYTE $0xcd // decq %r13 + WORD $0x214d; BYTE $0xe5 // andq %r12, %r13 + WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 + QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax + WORD $0x094c; BYTE $0xe8 // orq %r13, %rax + LONG $0x187f8341; BYTE $0x00 // cmpl $0, $24(%r15) + LONG $0xc5440f49 // cmoveq %r13, %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + WORD $0xc031 // xorl %eax, %eax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB13_69: + WORD $0xf980; BYTE $0x35 // cmpb $53, %cl + WORD $0x9d0f; BYTE $0xc2 // setge %dl + LONG $0xffff74e9; BYTE $0xff // jmp LBB13_70, $-140(%rip) + + // .p2align 4, 0x90 +_atof_native: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x28ec8348 // subq $40, %rsp + QUAD $0x00000000d045c748 // movq $0, $-48(%rbp) + LONG $0xb0558948 // movq %rdx, $-80(%rbp) + LONG $0xb84d8948 // movq %rcx, $-72(%rbp) + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0197840f; WORD $0x0000 // je LBB14_18, $407(%rip) + LONG $0x10f98348 // cmpq $16, %rcx + LONG $0x0008830f; WORD $0x0000 // jae LBB14_3, $8(%rip) + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x000174e9; BYTE $0x00 // jmp LBB14_17, $372(%rip) + +LBB14_3: + LONG $0x80f98148; WORD $0x0000; BYTE $0x00 // cmpq $128, %rcx + LONG $0x0008830f; WORD $0x0000 // jae LBB14_5, $8(%rip) + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x000129e9; BYTE $0x00 // jmp LBB14_14, $297(%rip) + +LBB14_5: + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0x80e28349 // andq $-128, %r10 + LONG $0x80428d49 // leaq $-128(%r10), %rax + WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 + LONG $0x07e9c149 // shrq $7, %r9 + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0x8945; BYTE $0xc8 // movl %r9d, %r8d + LONG $0x03e08341 // andl $3, %r8d + LONG $0x01803d48; WORD $0x0000 // cmpq $384, %rax + LONG $0x0007830f; WORD $0x0000 // jae LBB14_7, $7(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x0000a4e9; BYTE $0x00 // jmp LBB14_9, $164(%rip) + +LBB14_7: + LONG $0xfce18349 // andq $-4, %r9 + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB14_8: + LONG $0x0411fcc5; BYTE $0x1a // vmovups %ymm0, (%rdx,%rbx) + LONG $0x4411fcc5; WORD $0x201a // vmovups %ymm0, $32(%rdx,%rbx) + LONG $0x4411fcc5; WORD $0x401a // vmovups %ymm0, $64(%rdx,%rbx) + LONG $0x4411fcc5; WORD $0x601a // vmovups %ymm0, $96(%rdx,%rbx) + QUAD $0x0000801a8411fcc5; BYTE $0x00 // vmovups %ymm0, $128(%rdx,%rbx) + QUAD $0x0000a01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $160(%rdx,%rbx) + QUAD $0x0000c01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $192(%rdx,%rbx) + QUAD $0x0000e01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $224(%rdx,%rbx) + QUAD $0x0001001a8411fcc5; BYTE $0x00 // vmovups %ymm0, $256(%rdx,%rbx) + QUAD $0x0001201a8411fcc5; BYTE $0x00 // vmovups %ymm0, $288(%rdx,%rbx) + QUAD $0x0001401a8411fcc5; BYTE $0x00 // vmovups %ymm0, $320(%rdx,%rbx) + QUAD $0x0001601a8411fcc5; BYTE $0x00 // vmovups %ymm0, $352(%rdx,%rbx) + QUAD $0x0001801a8411fcc5; BYTE $0x00 // vmovups %ymm0, $384(%rdx,%rbx) + QUAD $0x0001a01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $416(%rdx,%rbx) + QUAD $0x0001c01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $448(%rdx,%rbx) + QUAD $0x0001e01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $480(%rdx,%rbx) + LONG $0x00c38148; WORD $0x0002; BYTE $0x00 // addq $512, %rbx + LONG $0xfcc18349 // addq $-4, %r9 + LONG $0xff6c850f; WORD $0xffff // jne LBB14_8, $-148(%rip) + +LBB14_9: + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x003b840f; WORD $0x0000 // je LBB14_12, $59(%rip) + LONG $0x130c8d4c // leaq (%rbx,%rdx), %r9 + LONG $0x60c18349 // addq $96, %r9 + LONG $0x07e0c149 // shlq $7, %r8 + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + BYTE $0x90 // .p2align 4, 0x90 + +LBB14_11: + LONG $0x117cc1c4; WORD $0x1944; BYTE $0xa0 // vmovups %ymm0, $-96(%r9,%rbx) + LONG $0x117cc1c4; WORD $0x1944; BYTE $0xc0 // vmovups %ymm0, $-64(%r9,%rbx) + LONG $0x117cc1c4; WORD $0x1944; BYTE $0xe0 // vmovups %ymm0, $-32(%r9,%rbx) + LONG $0x117cc1c4; WORD $0x1904 // vmovups %ymm0, (%r9,%rbx) + LONG $0x80eb8348 // subq $-128, %rbx + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0xffd8850f; WORD $0xffff // jne LBB14_11, $-40(%rip) + +LBB14_12: + WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 + LONG $0x0050840f; WORD $0x0000 // je LBB14_18, $80(%rip) + WORD $0xc1f6; BYTE $0x70 // testb $112, %cl + LONG $0x0036840f; WORD $0x0000 // je LBB14_17, $54(%rip) + +LBB14_14: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0xf0e28349 // andq $-16, %r10 + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB14_15: + LONG $0x0411f8c5; BYTE $0x02 // vmovups %xmm0, (%rdx,%rax) + LONG $0x10c08348 // addq $16, %rax + WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 + LONG $0xffee850f; WORD $0xffff // jne LBB14_15, $-18(%rip) + WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 + LONG $0x0016840f; WORD $0x0000 // je LBB14_18, $22(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB14_17: + LONG $0x1204c642; BYTE $0x00 // movb $0, (%rdx,%r10) + WORD $0xff49; BYTE $0xc2 // incq %r10 + WORD $0x394c; BYTE $0xd1 // cmpq %r10, %rcx + LONG $0xffef850f; WORD $0xffff // jne LBB14_17, $-17(%rip) + +LBB14_18: + LONG $0x00c045c7; WORD $0x0000; BYTE $0x00 // movl $0, $-64(%rbp) + QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3f80; BYTE $0x2d // cmpb $45, (%rdi) + LONG $0x001b850f; WORD $0x0000 // jne LBB14_19, $27(%rip) + LONG $0x01c845c7; WORD $0x0000; BYTE $0x00 // movl $1, $-56(%rbp) + LONG $0x0001bd41; WORD $0x0000 // movl $1, %r13d + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0x00118c0f; WORD $0x0000 // jl LBB14_22, $17(%rip) + LONG $0x0001b5e9; BYTE $0x00 // jmp LBB14_54, $437(%rip) + +LBB14_19: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0x01a98d0f; WORD $0x0000 // jge LBB14_54, $425(%rip) + +LBB14_22: + WORD $0xb741; BYTE $0x01 // movb $1, %r15b + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x000027e9; BYTE $0x00 // jmp LBB14_23, $39(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB14_33: + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x8945; BYTE $0xdc // movl %r11d, %r12d + WORD $0x2e3c // cmpb $46, %al + LONG $0x0095850f; WORD $0x0000 // jne LBB14_36, $149(%rip) + +LBB14_34: + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0xc79c0f41 // setl %r15b + LONG $0x007c840f; WORD $0x0000 // je LBB14_35, $124(%rip) + +LBB14_23: + WORD $0x8941; BYTE $0xda // movl %ebx, %r10d + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + LONG $0x04b60f42; BYTE $0x2f // movzbl (%rdi,%r13), %eax + WORD $0x588d; BYTE $0xd0 // leal $-48(%rax), %ebx + WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl + LONG $0xffc9870f; WORD $0xffff // ja LBB14_33, $-55(%rip) + WORD $0x303c // cmpb $48, %al + LONG $0x0021850f; WORD $0x0000 // jne LBB14_29, $33(%rip) + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x0043840f; WORD $0x0000 // je LBB14_26, $67(%rip) + WORD $0x6349; BYTE $0xd8 // movslq %r8d, %rbx + WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx + LONG $0x0018820f; WORD $0x0000 // jb LBB14_32, $24(%rip) + LONG $0x000019e9; BYTE $0x00 // jmp LBB14_28, $25(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB14_29: + WORD $0x6349; BYTE $0xdb // movslq %r11d, %rbx + WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx + LONG $0x0014830f; WORD $0x0000 // jae LBB14_30, $20(%rip) + +LBB14_32: + WORD $0x0488; BYTE $0x1a // movb %al, (%rdx,%rbx) + WORD $0xff41; BYTE $0xc0 // incl %r8d + +LBB14_28: + WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d + WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d + WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx + LONG $0xffff90e9; BYTE $0xff // jmp LBB14_34, $-112(%rip) + +LBB14_30: + LONG $0x0001b941; WORD $0x0000 // movl $1, %r9d + LONG $0x000006e9; BYTE $0x00 // jmp LBB14_31, $6(%rip) + +LBB14_26: + WORD $0xff41; BYTE $0xce // decl %r14d + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + +LBB14_31: + WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d + WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx + LONG $0xffff74e9; BYTE $0xff // jmp LBB14_34, $-140(%rip) + +LBB14_35: + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 + WORD $0x8941; BYTE $0xda // movl %ebx, %r10d + +LBB14_36: + LONG $0xc4758944 // movl %r14d, $-60(%rbp) + LONG $0xcc4d8944 // movl %r9d, $-52(%rbp) + LONG $0xc0458944 // movl %r8d, $-64(%rbp) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0012840f; WORD $0x0000 // je LBB14_37, $18(%rip) + WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d + LONG $0x01c7f641 // testb $1, %r15b + LONG $0x0013850f; WORD $0x0000 // jne LBB14_40, $19(%rip) + LONG $0x0000c4e9; BYTE $0x00 // jmp LBB14_55, $196(%rip) + +LBB14_37: + LONG $0xc4458944 // movl %r8d, $-60(%rbp) + LONG $0x01c7f641 // testb $1, %r15b + LONG $0x00b6840f; WORD $0x0000 // je LBB14_55, $182(%rip) + +LBB14_40: + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0xc983; BYTE $0x20 // orl $32, %ecx + WORD $0xf983; BYTE $0x65 // cmpl $101, %ecx + LONG $0x00a3850f; WORD $0x0000 // jne LBB14_55, $163(%rip) + LONG $0x0754b60f; BYTE $0x01 // movzbl $1(%rdi,%rax), %edx + WORD $0xfa83; BYTE $0x2d // cmpl $45, %edx + LONG $0x0017840f; WORD $0x0000 // je LBB14_45, $23(%rip) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + WORD $0xfa83; BYTE $0x2b // cmpl $43, %edx + LONG $0x0028850f; WORD $0x0000 // jne LBB14_43, $40(%rip) + LONG $0x02c58341 // addl $2, %r13d + LONG $0x000009e9; BYTE $0x00 // jmp LBB14_46, $9(%rip) + +LBB14_45: + LONG $0x02c58341 // addl $2, %r13d + LONG $0xffffffb9; BYTE $0xff // movl $-1, %ecx + +LBB14_46: + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x00168c0f; WORD $0x0000 // jl LBB14_48, $22(%rip) + LONG $0x000055e9; BYTE $0x00 // jmp LBB14_53, $85(%rip) + +LBB14_43: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x00448d0f; WORD $0x0000 // jge LBB14_53, $68(%rip) + +LBB14_48: + WORD $0xc031 // xorl %eax, %eax + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB14_49: + LONG $0x171cbe0f // movsbl (%rdi,%rdx), %ebx + WORD $0xfb83; BYTE $0x30 // cmpl $48, %ebx + LONG $0x00298c0f; WORD $0x0000 // jl LBB14_53, $41(%rip) + WORD $0xfb80; BYTE $0x39 // cmpb $57, %bl + LONG $0x0020870f; WORD $0x0000 // ja LBB14_53, $32(%rip) + LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax + LONG $0x00158f0f; WORD $0x0000 // jg LBB14_53, $21(%rip) + WORD $0x048d; BYTE $0x80 // leal (%rax,%rax,4), %eax + WORD $0x048d; BYTE $0x43 // leal (%rbx,%rax,2), %eax + WORD $0xc083; BYTE $0xd0 // addl $-48, %eax + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffca850f; WORD $0xffff // jne LBB14_49, $-54(%rip) + +LBB14_53: + WORD $0xaf0f; BYTE $0xc1 // imull %ecx, %eax + WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d + +LBB14_54: + LONG $0xc4458944 // movl %r8d, $-60(%rbp) + +LBB14_55: + LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi + LONG $0xd0758d48 // leaq $-48(%rbp), %rsi + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0xfff4b0e8; BYTE $0xff // callq _decimal_to_f64, $-2896(%rip) + LONG $0x4510fbc5; BYTE $0xd0 // vmovsd $-48(%rbp), %xmm0 + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +_value: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x28ec8348 // subq $40, %rsp + WORD $0x894d; BYTE $0xc7 // movq %r8, %r15 + WORD $0x8949; BYTE $0xce // movq %rcx, %r14 + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 + LONG $0xd0558948 // movq %rdx, $-48(%rbp) + LONG $0xb07d8948 // movq %rdi, $-80(%rbp) + LONG $0xb8758948 // movq %rsi, $-72(%rbp) + LONG $0xd0558d48 // leaq $-48(%rbp), %rdx + LONG $0x0005eee8; BYTE $0x00 // callq _advance_ns, $1518(%rip) + WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax + WORD $0xf883; BYTE $0x7d // cmpl $125, %eax + LONG $0x00bc870f; WORD $0x0000 // ja LBB15_11, $188(%rip) + LONG $0x9f0d8d48; WORD $0x0003; BYTE $0x00 // leaq $927(%rip), %rcx /* LJTI15_0(%rip) */ + LONG $0x81046348 // movslq (%rcx,%rax,4), %rax + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + JMP AX + +LBB15_2: + LONG $0xc875894c // movq %r14, $-56(%rbp) + LONG $0xd0758b4c // movq $-48(%rbp), %r14 + LONG $0xff6e8d4d // leaq $-1(%r14), %r13 + LONG $0xd06d894c // movq %r13, $-48(%rbp) + LONG $0x02c7f641 // testb $2, %r15b + LONG $0x001a850f; WORD $0x0000 // jne LBB15_4, $26(%rip) + LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi + LONG $0xd0758d48 // leaq $-48(%rbp), %rsi + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + LONG $0x000dc7e8; BYTE $0x00 // callq _vnumber, $3527(%rip) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x00034de9; BYTE $0x00 // jmp LBB15_58, $845(%rip) + +LBB15_4: + WORD $0xc031 // xorl %eax, %eax + LONG $0x2c3c8043; BYTE $0x2d // cmpb $45, (%r12,%r13) + LONG $0x2c3c8d4f // leaq (%r12,%r13), %r15 + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x2948; BYTE $0xc3 // subq %rax, %rbx + LONG $0x030c840f; WORD $0x0000 // je LBB15_53, $780(%rip) + WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 + LONG $0x000e830f; WORD $0x0000 // jae LBB15_7, $14(%rip) + LONG $0x07b60f41 // movzbl (%r15), %eax + WORD $0xc604 // addb $-58, %al + WORD $0xf63c // cmpb $-10, %al + LONG $0x0307820f; WORD $0x0000 // jb LBB15_55, $775(%rip) + +LBB15_7: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0x001f22e8; BYTE $0x00 // callq _do_skip_number, $7970(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x02ed880f; WORD $0x0000 // js LBB15_54, $749(%rip) + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x02f28e0f; WORD $0x0000 // jle LBB15_57, $754(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + LONG $0x0800c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rax) + LONG $0x1868894c // movq %r13, $24(%rax) + LONG $0x0002e5e9; BYTE $0x00 // jmp LBB15_58, $741(%rip) + +LBB15_10: + LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq $1, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x0002d5e9; BYTE $0x00 // jmp LBB15_58, $725(%rip) + +LBB15_11: + LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + WORD $0xff49; BYTE $0xcf // decq %r15 + LONG $0x0002c2e9; BYTE $0x00 // jmp LBB15_58, $706(%rip) + +LBB15_12: + QUAD $0xffffffffc045c748 // movq $-1, $-64(%rbp) + LONG $0xd0658b4c // movq $-48(%rbp), %r12 + LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi + LONG $0xc0558d48 // leaq $-64(%rbp), %rdx + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + LONG $0x000814e8; BYTE $0x00 // callq _advance_string, $2068(%rip) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0174880f; WORD $0x0000 // js LBB15_32, $372(%rip) + LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0x1066894d // movq %r12, $16(%r14) + LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0xc84c0f48 // cmovlq %rax, %rcx + LONG $0x184e8949 // movq %rcx, $24(%r14) + LONG $0x00026de9; BYTE $0x00 // jmp LBB15_58, $621(%rip) + +LBB15_14: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000bba; BYTE $0x00 // movl $11, %edx + LONG $0x00011ae9; BYTE $0x00 // jmp LBB15_31, $282(%rip) + +LBB15_15: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + LONG $0x000100e9; BYTE $0x00 // jmp LBB15_31, $256(%rip) + +LBB15_16: + LONG $0x0506c749; WORD $0x0000; BYTE $0x00 // movq $5, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x000229e9; BYTE $0x00 // jmp LBB15_58, $553(%rip) + +LBB15_17: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000cba; BYTE $0x00 // movl $12, %edx + LONG $0x0000d6e9; BYTE $0x00 // jmp LBB15_31, $214(%rip) + +LBB15_18: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0xfc4b8d48 // leaq $-4(%rbx), %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x008a870f; WORD $0x0000 // ja LBB15_25, $138(%rip) + LONG $0x3c0c8b43 // movl (%r12,%r15), %ecx + LONG $0x6c61f981; WORD $0x6573 // cmpl $1702063201, %ecx + LONG $0x00d3850f; WORD $0x0000 // jne LBB15_33, $211(%rip) + LONG $0x04c78349 // addq $4, %r15 + LONG $0x000004b8; BYTE $0x00 // movl $4, %eax + LONG $0x000069e9; BYTE $0x00 // jmp LBB15_24, $105(%rip) + +LBB15_21: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x0054870f; WORD $0x0000 // ja LBB15_25, $84(%rip) + LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx + LONG $0x756ef981; WORD $0x6c6c // cmpl $1819047278, %ecx + LONG $0x00db850f; WORD $0x0000 // jne LBB15_37, $219(%rip) + LONG $0x03c78349 // addq $3, %r15 + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + LONG $0x000032e9; BYTE $0x00 // jmp LBB15_24, $50(%rip) + +LBB15_26: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x001d870f; WORD $0x0000 // ja LBB15_25, $29(%rip) + LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx + LONG $0x7274f981; WORD $0x6575 // cmpl $1702195828, %ecx + LONG $0x00e2850f; WORD $0x0000 // jne LBB15_41, $226(%rip) + LONG $0x03c78349 // addq $3, %r15 + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + +LBB15_24: + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + +LBB15_25: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x00015ee9; BYTE $0x00 // jmp LBB15_58, $350(%rip) + +LBB15_29: + LONG $0x0606c749; WORD $0x0000; BYTE $0x00 // movq $6, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x00014ee9; BYTE $0x00 // jmp LBB15_58, $334(%rip) + +LBB15_30: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000dba; BYTE $0x00 // movl $13, %edx + +LBB15_31: + LONG $0xd1440f48 // cmoveq %rcx, %rdx + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 + LONG $0x000123e9; BYTE $0x00 // jmp LBB15_58, $291(%rip) + +LBB15_32: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x894d; BYTE $0x3e // movq %r15, (%r14) + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x000114e9; BYTE $0x00 // jmp LBB15_58, $276(%rip) + +LBB15_33: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xf980; BYTE $0x61 // cmpb $97, %cl + LONG $0x00d5850f; WORD $0x0000 // jne LBB15_49, $213(%rip) + LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) + LONG $0x00aa850f; WORD $0x0000 // jne LBB15_46, $170(%rip) + LONG $0x3c7c8043; WORD $0x7302 // cmpb $115, $2(%r12,%r15) + LONG $0x00b5850f; WORD $0x0000 // jne LBB15_47, $181(%rip) + LONG $0x044f8d49 // leaq $4(%r15), %rcx + LONG $0x3c7c8043; WORD $0x6503 // cmpb $101, $3(%r12,%r15) + LONG $0x037f8d4d // leaq $3(%r15), %r15 + LONG $0xf9440f4c // cmoveq %rcx, %r15 + LONG $0x0000a2e9; BYTE $0x00 // jmp LBB15_48, $162(%rip) + +LBB15_37: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xf980; BYTE $0x6e // cmpb $110, %cl + LONG $0x006c850f; WORD $0x0000 // jne LBB15_45, $108(%rip) + LONG $0x3c3c8043; BYTE $0x75 // cmpb $117, (%r12,%r15) + LONG $0x0077850f; WORD $0x0000 // jne LBB15_51, $119(%rip) + LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) + LONG $0x0068850f; WORD $0x0000 // jne LBB15_50, $104(%rip) + LONG $0x034f8d49 // leaq $3(%r15), %rcx + LONG $0x3c7c8043; WORD $0x6c02 // cmpb $108, $2(%r12,%r15) + LONG $0x027f8d4d // leaq $2(%r15), %r15 + LONG $0xf9440f4c // cmoveq %rcx, %r15 + LONG $0x000054e9; BYTE $0x00 // jmp LBB15_51, $84(%rip) + +LBB15_41: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xf980; BYTE $0x74 // cmpb $116, %cl + LONG $0x002e850f; WORD $0x0000 // jne LBB15_45, $46(%rip) + LONG $0x3c3c8043; BYTE $0x72 // cmpb $114, (%r12,%r15) + LONG $0x0039850f; WORD $0x0000 // jne LBB15_51, $57(%rip) + LONG $0x3c7c8043; WORD $0x7501 // cmpb $117, $1(%r12,%r15) + LONG $0x002a850f; WORD $0x0000 // jne LBB15_50, $42(%rip) + LONG $0x034f8d49 // leaq $3(%r15), %rcx + LONG $0x3c7c8043; WORD $0x6502 // cmpb $101, $2(%r12,%r15) + LONG $0x027f8d4d // leaq $2(%r15), %r15 + LONG $0xf9440f4c // cmoveq %rcx, %r15 + LONG $0x000016e9; BYTE $0x00 // jmp LBB15_51, $22(%rip) + +LBB15_45: + WORD $0xff49; BYTE $0xcf // decq %r15 + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x00004ee9; BYTE $0x00 // jmp LBB15_58, $78(%rip) + +LBB15_46: + WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0x000013e9; BYTE $0x00 // jmp LBB15_48, $19(%rip) + +LBB15_50: + WORD $0xff49; BYTE $0xc7 // incq %r15 + +LBB15_51: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x000037e9; BYTE $0x00 // jmp LBB15_58, $55(%rip) + +LBB15_47: + LONG $0x02c78349 // addq $2, %r15 + +LBB15_48: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + +LBB15_49: + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x000027e9; BYTE $0x00 // jmp LBB15_58, $39(%rip) + +LBB15_53: + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + LONG $0x00000de9; BYTE $0x00 // jmp LBB15_56, $13(%rip) + +LBB15_54: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + +LBB15_55: + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + +LBB15_56: + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + LONG $0xd07d894c // movq %r15, $-48(%rbp) + +LBB15_57: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) + +LBB15_58: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90 + + // .set L15_0_set_10, LBB15_10-LJTI15_0 + // .set L15_0_set_11, LBB15_11-LJTI15_0 + // .set L15_0_set_12, LBB15_12-LJTI15_0 + // .set L15_0_set_14, LBB15_14-LJTI15_0 + // .set L15_0_set_2, LBB15_2-LJTI15_0 + // .set L15_0_set_15, LBB15_15-LJTI15_0 + // .set L15_0_set_16, LBB15_16-LJTI15_0 + // .set L15_0_set_17, LBB15_17-LJTI15_0 + // .set L15_0_set_18, LBB15_18-LJTI15_0 + // .set L15_0_set_21, LBB15_21-LJTI15_0 + // .set L15_0_set_26, LBB15_26-LJTI15_0 + // .set L15_0_set_29, LBB15_29-LJTI15_0 + // .set L15_0_set_30, LBB15_30-LJTI15_0 +LJTI15_0: + LONG $0xfffffd06 // .long L15_0_set_10 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd29 // .long L15_0_set_12 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd7e // .long L15_0_set_14 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffd98 // .long L15_0_set_15 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffdb2 // .long L15_0_set_16 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffdc2 // .long L15_0_set_17 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffddc // .long L15_0_set_18 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe12 // .long L15_0_set_21 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe49 // .long L15_0_set_26 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe8d // .long L15_0_set_29 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe9d // .long L15_0_set_30 + LONG $0x00000000 // .p2align 4, 0x00 + +LCPI16_0: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + +LCPI16_1: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI16_2: + QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' + +LCPI16_3: + QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + + // .p2align 4, 0x90 +_advance_ns: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8b4c; BYTE $0x02 // movq (%rdx), %r8 + WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 + LONG $0x0029830f; WORD $0x0000 // jae LBB16_6, $41(%rip) + LONG $0x04b60f42; BYTE $0x07 // movzbl (%rdi,%r8), %eax + WORD $0xf883; BYTE $0x0d // cmpl $13, %eax + LONG $0x001b840f; WORD $0x0000 // je LBB16_6, $27(%rip) + WORD $0xf883; BYTE $0x20 // cmpl $32, %eax + LONG $0x0012840f; WORD $0x0000 // je LBB16_6, $18(%rip) + WORD $0xf504 // addb $-11, %al + WORD $0xfe3c // cmpb $-2, %al + LONG $0x0008830f; WORD $0x0000 // jae LBB16_6, $8(%rip) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x000207e9; BYTE $0x00 // jmp LBB16_5, $519(%rip) + +LBB16_6: + LONG $0x01408d49 // leaq $1(%r8), %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x0022830f; WORD $0x0000 // jae LBB16_10, $34(%rip) + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx + LONG $0x0015840f; WORD $0x0000 // je LBB16_10, $21(%rip) + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x000c840f; WORD $0x0000 // je LBB16_10, $12(%rip) + WORD $0xc180; BYTE $0xf5 // addb $-11, %cl + WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl + LONG $0x01d8820f; WORD $0x0000 // jb LBB16_5, $472(%rip) + +LBB16_10: + LONG $0x02408d49 // leaq $2(%r8), %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x0022830f; WORD $0x0000 // jae LBB16_14, $34(%rip) + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx + LONG $0x0015840f; WORD $0x0000 // je LBB16_14, $21(%rip) + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x000c840f; WORD $0x0000 // je LBB16_14, $12(%rip) + WORD $0xc180; BYTE $0xf5 // addb $-11, %cl + WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl + LONG $0x01a9820f; WORD $0x0000 // jb LBB16_5, $425(%rip) + +LBB16_14: + LONG $0x03408d49 // leaq $3(%r8), %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x0022830f; WORD $0x0000 // jae LBB16_18, $34(%rip) + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx + LONG $0x0015840f; WORD $0x0000 // je LBB16_18, $21(%rip) + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x000c840f; WORD $0x0000 // je LBB16_18, $12(%rip) + WORD $0xc180; BYTE $0xf5 // addb $-11, %cl + WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl + LONG $0x017a820f; WORD $0x0000 // jb LBB16_5, $378(%rip) + +LBB16_18: + LONG $0x04c08349 // addq $4, %r8 + WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 + LONG $0x014d830f; WORD $0x0000 // jae LBB16_19, $333(%rip) + LONG $0x070c8d4e // leaq (%rdi,%r8), %r9 + WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 + WORD $0x294d; BYTE $0xc3 // subq %r8, %r11 + LONG $0x0073840f; WORD $0x0000 // je LBB16_27, $115(%rip) + WORD $0x8944; BYTE $0xc8 // movl %r9d, %eax + WORD $0xe083; BYTE $0x0f // andl $15, %eax + LONG $0x0067840f; WORD $0x0000 // je LBB16_27, $103(%rip) + LONG $0x0005ba41; WORD $0x0000 // movl $5, %r10d + WORD $0x2949; BYTE $0xf2 // subq %rsi, %r10 + QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB16_23: + LONG $0x0cbe0f42; BYTE $0x07 // movsbl (%rdi,%r8), %ecx + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x0116870f; WORD $0x0000 // ja LBB16_42, $278(%rip) + LONG $0xc9a30f49 // btq %rcx, %r9 + LONG $0x010c830f; WORD $0x0000 // jae LBB16_42, $268(%rip) + LONG $0x02048d4b // leaq (%r10,%r8), %rax + LONG $0x01488d49 // leaq $1(%r8), %rcx + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x0012840f; WORD $0x0000 // je LBB16_26, $18(%rip) + LONG $0x07048d42 // leal (%rdi,%r8), %eax + WORD $0xc0ff // incl %eax + WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 + WORD $0xe083; BYTE $0x0f // andl $15, %eax + LONG $0xffc4850f; WORD $0xffff // jne LBB16_23, $-60(%rip) + +LBB16_26: + LONG $0x0f0c8d4c // leaq (%rdi,%rcx), %r9 + WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 + WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 + +LBB16_27: + LONG $0x10fb8349 // cmpq $16, %r11 + LONG $0x0075820f; WORD $0x0000 // jb LBB16_33, $117(%rip) + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + WORD $0x294c; BYTE $0xc9 // subq %r9, %rcx + QUAD $0xfffffe52056ff9c5 // vmovdqa $-430(%rip), %xmm0 /* LCPI16_0(%rip) */ + QUAD $0xfffffe5a0d6ff9c5 // vmovdqa $-422(%rip), %xmm1 /* LCPI16_1(%rip) */ + QUAD $0xfffffe62156ff9c5 // vmovdqa $-414(%rip), %xmm2 /* LCPI16_2(%rip) */ + QUAD $0xfffffe6a1d6ff9c5 // vmovdqa $-406(%rip), %xmm3 /* LCPI16_3(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB16_29: + LONG $0x6f79c1c4; BYTE $0x21 // vmovdqa (%r9), %xmm4 + LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 + LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 + LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 + LONG $0xf274d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm6 + LONG $0xe374d9c5 // vpcmpeqb %xmm3, %xmm4, %xmm4 + LONG $0xe6ebd9c5 // vpor %xmm6, %xmm4, %xmm4 + LONG $0xe5ebd9c5 // vpor %xmm5, %xmm4, %xmm4 + LONG $0xc4d7f9c5 // vpmovmskb %xmm4, %eax + LONG $0xfff88366 // cmpw $-1, %ax + LONG $0x0069850f; WORD $0x0000 // jne LBB16_30, $105(%rip) + LONG $0x10c18349 // addq $16, %r9 + LONG $0xf0c38349 // addq $-16, %r11 + LONG $0xf0c18348 // addq $-16, %rcx + LONG $0x0ffb8349 // cmpq $15, %r11 + LONG $0xffbb870f; WORD $0xffff // ja LBB16_29, $-69(%rip) + +LBB16_33: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0037840f; WORD $0x0000 // je LBB16_40, $55(%rip) + LONG $0x19048d4f // leaq (%r9,%r11), %r8 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x000100002600ba49; WORD $0x0000 // movabsq $4294977024, %r10 + +LBB16_35: + LONG $0x04be0f41; BYTE $0x09 // movsbl (%r9,%rcx), %eax + WORD $0xf883; BYTE $0x20 // cmpl $32, %eax + LONG $0x005b870f; WORD $0x0000 // ja LBB16_37, $91(%rip) + LONG $0xc2a30f49 // btq %rax, %r10 + LONG $0x0051830f; WORD $0x0000 // jae LBB16_37, $81(%rip) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 + LONG $0xffdc850f; WORD $0xffff // jne LBB16_35, $-36(%rip) + WORD $0x894d; BYTE $0xc1 // movq %r8, %r9 + +LBB16_40: + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + +LBB16_41: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + LONG $0x000014e9; BYTE $0x00 // jmp LBB16_42, $20(%rip) + +LBB16_19: + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + LONG $0x000028e9; BYTE $0x00 // jmp LBB16_43, $40(%rip) + +LBB16_30: + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0xd0f7 // notl %eax + LONG $0xc0bc0f44 // bsfl %eax, %r8d + WORD $0x2949; BYTE $0xc8 // subq %rcx, %r8 + +LBB16_42: + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 + LONG $0x0010830f; WORD $0x0000 // jae LBB16_43, $16(%rip) + +LBB16_5: + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x0704b60f // movzbl (%rdi,%rax), %eax + WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB16_43: + WORD $0xc031 // xorl %eax, %eax + WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB16_37: + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + LONG $0xffffb6e9; BYTE $0xff // jmp LBB16_41, $-74(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_vstring: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x10ec8348 // subq $16, %rsp + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + QUAD $0xffffffffd845c748 // movq $-1, $-40(%rbp) + WORD $0x8b4c; BYTE $0x26 // movq (%rsi), %r12 + LONG $0xd8558d48 // leaq $-40(%rbp), %rdx + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0x000081e8; BYTE $0x00 // callq _advance_string, $129(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0029880f; WORD $0x0000 // js LBB17_1, $41(%rip) + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0x1066894d // movq %r12, $16(%r14) + LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) + LONG $0xd84d8b48 // movq $-40(%rbp), %rcx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xc14c0f48 // cmovlq %rcx, %rax + LONG $0x18468949 // movq %rax, $24(%r14) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB17_3, $10(%rip) + +LBB17_1: + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + +LBB17_3: + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +LCPI18_0: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI18_1: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI18_2: + QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' + + // .p2align 4, 0x90 +_advance_string: + WORD $0xc1f6; BYTE $0x20 // testb $32, %cl + LONG $0x0005850f; WORD $0x0000 // jne LBB18_2, $5(%rip) + LONG $0x004572e9; BYTE $0x00 // jmp _advance_string_default, $17778(%rip) + +LBB18_2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x18ec8348 // subq $24, %rsp + LONG $0x087f8b4c // movq $8(%rdi), %r15 + WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 + LONG $0x0483840f; WORD $0x0000 // je LBB18_47, $1155(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + LONG $0xd0458948 // movq %rax, $-48(%rbp) + LONG $0xc0558948 // movq %rdx, $-64(%rbp) + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + LONG $0x40ff8349 // cmpq $64, %r15 + LONG $0x0390820f; WORD $0x0000 // jb LBB18_48, $912(%rip) + QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + QUAD $0xffffff75056ff9c5 // vmovdqa $-139(%rip), %xmm0 /* LCPI18_0(%rip) */ + QUAD $0xffffff7d0d6ff9c5 // vmovdqa $-131(%rip), %xmm1 /* LCPI18_1(%rip) */ + QUAD $0xffffff85156ff9c5 // vmovdqa $-123(%rip), %xmm2 /* LCPI18_2(%rip) */ + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB18_5: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + LONG $0x1c6ffac5; BYTE $0x30 // vmovdqu (%rax,%rsi), %xmm3 + LONG $0x646ffac5; WORD $0x1030 // vmovdqu $16(%rax,%rsi), %xmm4 + LONG $0x6c6ffac5; WORD $0x2030 // vmovdqu $32(%rax,%rsi), %xmm5 + LONG $0x746ffac5; WORD $0x3030 // vmovdqu $48(%rax,%rsi), %xmm6 + LONG $0xf874e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm7 + LONG $0xe7d779c5 // vpmovmskb %xmm7, %r12d + LONG $0xf874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm7 + LONG $0xcfd779c5 // vpmovmskb %xmm7, %r9d + LONG $0xf874d1c5 // vpcmpeqb %xmm0, %xmm5, %xmm7 + LONG $0xdfd779c5 // vpmovmskb %xmm7, %r11d + LONG $0xf874c9c5 // vpcmpeqb %xmm0, %xmm6, %xmm7 + LONG $0xd7d7f9c5 // vpmovmskb %xmm7, %edx + LONG $0xf974e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm7 + LONG $0xefd779c5 // vpmovmskb %xmm7, %r13d + LONG $0xf974d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm7 + LONG $0xcfd7f9c5 // vpmovmskb %xmm7, %ecx + LONG $0xf974d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm7 + LONG $0xffd7f9c5 // vpmovmskb %xmm7, %edi + LONG $0xf974c9c5 // vpcmpeqb %xmm1, %xmm6, %xmm7 + LONG $0xd7d779c5 // vpmovmskb %xmm7, %r10d + LONG $0xfadad9c5 // vpminub %xmm2, %xmm4, %xmm7 + LONG $0xe774d9c5 // vpcmpeqb %xmm7, %xmm4, %xmm4 + LONG $0xdcd7f9c5 // vpmovmskb %xmm4, %ebx + LONG $0xe2dad1c5 // vpminub %xmm2, %xmm5, %xmm4 + LONG $0xe474d1c5 // vpcmpeqb %xmm4, %xmm5, %xmm4 + LONG $0xc4d7f9c5 // vpmovmskb %xmm4, %eax + LONG $0xe2dac9c5 // vpminub %xmm2, %xmm6, %xmm4 + LONG $0xe474c9c5 // vpcmpeqb %xmm4, %xmm6, %xmm4 + LONG $0xc4d779c5 // vpmovmskb %xmm4, %r8d + LONG $0x30e2c148 // shlq $48, %rdx + LONG $0x20e3c149 // shlq $32, %r11 + WORD $0x0949; BYTE $0xd3 // orq %rdx, %r11 + LONG $0x10e1c149 // shlq $16, %r9 + WORD $0x094d; BYTE $0xd9 // orq %r11, %r9 + WORD $0x094d; BYTE $0xcc // orq %r9, %r12 + LONG $0x30e2c149 // shlq $48, %r10 + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x094c; BYTE $0xd7 // orq %r10, %rdi + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx + LONG $0x30e0c149 // shlq $48, %r8 + LONG $0x20e0c148 // shlq $32, %rax + WORD $0x094c; BYTE $0xc0 // orq %r8, %rax + LONG $0x10e3c148 // shlq $16, %rbx + WORD $0x0948; BYTE $0xc3 // orq %rax, %rbx + WORD $0x0949; BYTE $0xcd // orq %rcx, %r13 + LONG $0x0044850f; WORD $0x0000 // jne LBB18_11, $68(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0058850f; WORD $0x0000 // jne LBB18_13, $88(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + +LBB18_8: + LONG $0xe2dae1c5 // vpminub %xmm2, %xmm3, %xmm4 + LONG $0xdc74e1c5 // vpcmpeqb %xmm4, %xmm3, %xmm3 + LONG $0xc3d7f9c5 // vpmovmskb %xmm3, %eax + WORD $0x0948; BYTE $0xc3 // orq %rax, %rbx + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x008b850f; WORD $0x0000 // jne LBB18_14, $139(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00d5850f; WORD $0x0000 // jne LBB18_20, $213(%rip) + LONG $0xc0c78349 // addq $-64, %r15 + LONG $0x40c68348 // addq $64, %rsi + LONG $0x3fff8349 // cmpq $63, %r15 + LONG $0xff00870f; WORD $0xffff // ja LBB18_5, $-256(%rip) + LONG $0x0000e3e9; BYTE $0x00 // jmp LBB18_22, $227(%rip) + +LBB18_11: + LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) + LONG $0x0012850f; WORD $0x0000 // jne LBB18_13, $18(%rip) + LONG $0xcdbc0f49 // bsfq %r13, %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0xc0458b48 // movq $-64(%rbp), %rax + LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + +LBB18_13: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x214c; BYTE $0xe8 // andq %r13, %rax + LONG $0x000c8d48 // leaq (%rax,%rax), %rcx + WORD $0x094c; BYTE $0xf1 // orq %r14, %rcx + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x214c; BYTE $0xea // andq %r13, %rdx + QUAD $0xaaaaaaaaaaaabf48; WORD $0xaaaa // movabsq $-6148914691236517206, %rdi + WORD $0x2148; BYTE $0xfa // andq %rdi, %rdx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0xc6920f41 // setb %r14b + WORD $0x0148; BYTE $0xd2 // addq %rdx, %rdx + QUAD $0x555555555555b848; WORD $0x5555 // movabsq $6148914691236517205, %rax + WORD $0x3148; BYTE $0xc2 // xorq %rax, %rdx + WORD $0x2148; BYTE $0xca // andq %rcx, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x2149; BYTE $0xd4 // andq %rdx, %r12 + LONG $0xffff5de9; BYTE $0xff // jmp LBB18_8, $-163(%rip) + +LBB18_14: + LONG $0xc4bc0f49 // bsfq %r12, %rax + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0022840f; WORD $0x0000 // je LBB18_18, $34(%rip) + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x0023820f; WORD $0x0000 // jb LBB18_19, $35(%rip) + +LBB18_16: + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + +LBB18_17: + LONG $0x18c48348 // addq $24, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB18_18: + LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffdd830f; WORD $0xffff // jae LBB18_16, $-35(%rip) + +LBB18_19: + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xffffcde9; BYTE $0xff // jmp LBB18_17, $-51(%rip) + +LBB18_20: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) + LONG $0xffbb850f; WORD $0xffff // jne LBB18_17, $-69(%rip) + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0xc0558b48 // movq $-64(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0xffffa8e9; BYTE $0xff // jmp LBB18_17, $-88(%rip) + +LBB18_22: + LONG $0xd0750348 // addq $-48(%rbp), %rsi + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x00d7820f; WORD $0x0000 // jb LBB18_35, $215(%rip) + +LBB18_23: + LONG $0x066ffac5 // vmovdqu (%rsi), %xmm0 + LONG $0x4e6ffac5; BYTE $0x10 // vmovdqu $16(%rsi), %xmm1 + QUAD $0xfffffd59156ff9c5 // vmovdqa $-679(%rip), %xmm2 /* LCPI18_0(%rip) */ + LONG $0xda74f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm3 + LONG $0xc3d7f9c5 // vpmovmskb %xmm3, %eax + LONG $0xd274f1c5 // vpcmpeqb %xmm2, %xmm1, %xmm2 + LONG $0xcad7f9c5 // vpmovmskb %xmm2, %ecx + QUAD $0xfffffd51156ff9c5 // vmovdqa $-687(%rip), %xmm2 /* LCPI18_1(%rip) */ + LONG $0xda74f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm3 + LONG $0xd3d779c5 // vpmovmskb %xmm3, %r10d + LONG $0xd274f1c5 // vpcmpeqb %xmm2, %xmm1, %xmm2 + LONG $0xd2d7f9c5 // vpmovmskb %xmm2, %edx + QUAD $0xfffffd49156ff9c5 // vmovdqa $-695(%rip), %xmm2 /* LCPI18_2(%rip) */ + LONG $0xdadaf9c5 // vpminub %xmm2, %xmm0, %xmm3 + LONG $0xc374f9c5 // vpcmpeqb %xmm3, %xmm0, %xmm0 + LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d + LONG $0xc2daf1c5 // vpminub %xmm2, %xmm1, %xmm0 + LONG $0xc074f1c5 // vpcmpeqb %xmm0, %xmm1, %xmm0 + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0x10e2c148 // shlq $16, %rdx + LONG $0x10e3c148 // shlq $16, %rbx + WORD $0x0949; BYTE $0xd2 // orq %rdx, %r10 + LONG $0x011f850f; WORD $0x0000 // jne LBB18_49, $287(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x013a850f; WORD $0x0000 // jne LBB18_51, $314(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + +LBB18_26: + WORD $0x094c; BYTE $0xcb // orq %r9, %rbx + LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx + LONG $0x000040ba; BYTE $0x00 // movl $64, %edx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0004840f; WORD $0x0000 // je LBB18_28, $4(%rip) + LONG $0xd0bc0f48 // bsfq %rax, %rdx + +LBB18_28: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0004840f; WORD $0x0000 // je LBB18_30, $4(%rip) + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + +LBB18_30: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0019840f; WORD $0x0000 // je LBB18_33, $25(%rip) + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x0135820f; WORD $0x0000 // jb LBB18_52, $309(%rip) + LONG $0xd0752b48 // subq $-48(%rbp), %rsi + LONG $0x16048d48 // leaq (%rsi,%rdx), %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xfffed4e9; BYTE $0xff // jmp LBB18_17, $-300(%rip) + +LBB18_33: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x011c850f; WORD $0x0000 // jne LBB18_52, $284(%rip) + LONG $0x20c68348 // addq $32, %rsi + LONG $0xe0c78349 // addq $-32, %r15 + +LBB18_35: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0125850f; WORD $0x0000 // jne LBB18_54, $293(%rip) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xfeaa840f; WORD $0xffff // je LBB18_17, $-342(%rip) + +LBB18_37: + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + +LBB18_38: + WORD $0xb60f; BYTE $0x0e // movzbl (%rsi), %ecx + WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx + LONG $0x0063840f; WORD $0x0000 // je LBB18_46, $99(%rip) + WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx + LONG $0x0026840f; WORD $0x0000 // je LBB18_43, $38(%rip) + WORD $0xf980; BYTE $0x1f // cmpb $31, %cl + LONG $0x0143860f; WORD $0x0000 // jbe LBB18_58, $323(%rip) + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + +LBB18_42: + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + LONG $0xffca850f; WORD $0xffff // jne LBB18_38, $-54(%rip) + LONG $0xfffe6be9; BYTE $0xff // jmp LBB18_17, $-405(%rip) + +LBB18_43: + LONG $0x01ff8349 // cmpq $1, %r15 + LONG $0xfe61840f; WORD $0xffff // je LBB18_17, $-415(%rip) + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) + LONG $0xffce850f; WORD $0xffff // jne LBB18_42, $-50(%rip) + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + LONG $0xd05d2b48 // subq $-48(%rbp), %rbx + LONG $0xc85d8948 // movq %rbx, $-56(%rbp) + WORD $0x8948; BYTE $0x1f // movq %rbx, (%rdi) + LONG $0xffffbbe9; BYTE $0xff // jmp LBB18_42, $-69(%rip) + +LBB18_46: + LONG $0xd0752b48 // subq $-48(%rbp), %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0xfffe28e9; BYTE $0xff // jmp LBB18_17, $-472(%rip) + +LBB18_48: + LONG $0xd0750348 // addq $-48(%rbp), %rsi + QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0xfe75830f; WORD $0xffff // jae LBB18_23, $-395(%rip) + LONG $0xffff47e9; BYTE $0xff // jmp LBB18_35, $-185(%rip) + +LBB18_49: + LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) + LONG $0x0019850f; WORD $0x0000 // jne LBB18_51, $25(%rip) + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + LONG $0xd04d2b48 // subq $-48(%rbp), %rcx + LONG $0xd2bc0f49 // bsfq %r10, %rdx + WORD $0x0148; BYTE $0xca // addq %rcx, %rdx + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + LONG $0xc8558948 // movq %rdx, $-56(%rbp) + WORD $0x8948; BYTE $0x11 // movq %rdx, (%rcx) + +LBB18_51: + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0x2144; BYTE $0xd1 // andl %r10d, %ecx + WORD $0x148d; BYTE $0x09 // leal (%rcx,%rcx), %edx + LONG $0x4e048d45 // leal (%r14,%rcx,2), %r8d + WORD $0xd2f7 // notl %edx + WORD $0x2144; BYTE $0xd2 // andl %r10d, %edx + LONG $0xaaaae281; WORD $0xaaaa // andl $-1431655766, %edx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0xca01 // addl %ecx, %edx + LONG $0xc6920f41 // setb %r14b + WORD $0xd201 // addl %edx, %edx + LONG $0x5555f281; WORD $0x5555 // xorl $1431655765, %edx + WORD $0x2144; BYTE $0xc2 // andl %r8d, %edx + WORD $0xd2f7 // notl %edx + WORD $0xd021 // andl %edx, %eax + LONG $0xfffe92e9; BYTE $0xff // jmp LBB18_26, $-366(%rip) + +LBB18_52: + LONG $0xd0752b48 // subq $-48(%rbp), %rsi + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + +LBB18_53: + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xfffd95e9; BYTE $0xff // jmp LBB18_17, $-619(%rip) + +LBB18_54: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x003b840f; WORD $0x0000 // je LBB18_47, $59(%rip) + LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) + LONG $0x0015850f; WORD $0x0000 // jne LBB18_57, $21(%rip) + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0xc0458b48 // movq $-64(%rbp), %rax + LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + +LBB18_57: + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff49; BYTE $0xcf // decq %r15 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xfeac850f; WORD $0xffff // jne LBB18_37, $-340(%rip) + LONG $0xfffd51e9; BYTE $0xff // jmp LBB18_17, $-687(%rip) + +LBB18_47: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffd45e9; BYTE $0xff // jmp LBB18_17, $-699(%rip) + +LBB18_58: + LONG $0xd0752b48 // subq $-48(%rbp), %rsi + LONG $0xffff94e9; BYTE $0xff // jmp LBB18_53, $-108(%rip) + QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 + +LCPI19_0: + LONG $0x43300000 // .long 1127219200 + LONG $0x45300000 // .long 1160773632 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + +LCPI19_1: + QUAD $0x4330000000000000 // .quad 0x4330000000000000 + QUAD $0x4530000000000000 // .quad 0x4530000000000000 + + // .p2align 3, 0x00 +LCPI19_2: + QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000 + +LCPI19_3: + QUAD $0xc30c6bf526340000 // .quad 0xc30c6bf526340000 + + // .p2align 4, 0x90 +_vnumber: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x38ec8348 // subq $56, %rsp + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax + WORD $0x8b4c; BYTE $0x3f // movq (%rdi), %r15 + LONG $0x086f8b4c // movq $8(%rdi), %r13 + LONG $0x20528b4c // movq $32(%rdx), %r10 + LONG $0x285a8b4c // movq $40(%rdx), %r11 + LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) + LONG $0xc057f9c5 // vxorpd %xmm0, %xmm0, %xmm0 + LONG $0x4211f9c5; BYTE $0x08 // vmovupd %xmm0, $8(%rdx) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + LONG $0x184a8948 // movq %rcx, $24(%rdx) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x02c9830f; WORD $0x0000 // jae LBB19_51, $713(%rip) + LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx + LONG $0x000001bf; BYTE $0x00 // movl $1, %edi + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl + LONG $0x0016850f; WORD $0x0000 // jne LBB19_4, $22(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x02aa830f; WORD $0x0000 // jae LBB19_51, $682(%rip) + LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx + LONG $0xffffffbf; BYTE $0xff // movl $-1, %edi + +LBB19_4: + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB19_6, $15(%rip) + +LBB19_5: + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) + LONG $0x00028fe9; BYTE $0x00 // jmp LBB19_52, $655(%rip) + +LBB19_6: + WORD $0xf980; BYTE $0x30 // cmpb $48, %cl + LONG $0x0032850f; WORD $0x0000 // jne LBB19_10, $50(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00a6830f; WORD $0x0000 // jae LBB19_18, $166(%rip) + LONG $0x14b60f41; BYTE $0x0f // movzbl (%r15,%rcx), %edx + WORD $0xc283; BYTE $0xd2 // addl $-46, %edx + WORD $0xfa83; BYTE $0x37 // cmpl $55, %edx + LONG $0x0095870f; WORD $0x0000 // ja LBB19_18, $149(%rip) + QUAD $0x000000800001be48; WORD $0x0080 // movabsq $36028797027352577, %rsi + LONG $0xd6a30f48 // btq %rdx, %rsi + LONG $0x0081830f; WORD $0x0000 // jae LBB19_18, $129(%rip) + +LBB19_10: + WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) + WORD $0x01b1 // movb $1, %cl + WORD $0x4d89; BYTE $0xc8 // movl %ecx, $-56(%rbp) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0063830f; WORD $0x0000 // jae LBB19_17, $99(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x000012e9; BYTE $0x00 // jmp LBB19_13, $18(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB19_12: + WORD $0xc1ff // incl %ecx + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0x0036840f; WORD $0x0000 // je LBB19_16, $54(%rip) + +LBB19_13: + LONG $0x14be0f49; BYTE $0x07 // movsbq (%r15,%rax), %rdx + WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x0041870f; WORD $0x0000 // ja LBB19_19, $65(%rip) + LONG $0x12f88341 // cmpl $18, %r8d + LONG $0xffd68f0f; WORD $0xffff // jg LBB19_12, $-42(%rip) + LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi + WORD $0x0144; BYTE $0xca // addl %r9d, %edx + LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 + WORD $0xff41; BYTE $0xc0 // incl %r8d + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0xffca850f; WORD $0xffff // jne LBB19_13, $-54(%rip) + +LBB19_16: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + LONG $0x00005be9; BYTE $0x00 // jmp LBB19_24, $91(%rip) + +LBB19_17: + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x00004ee9; BYTE $0x00 // jmp LBB19_24, $78(%rip) + +LBB19_18: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x0001cbe9; BYTE $0x00 // jmp LBB19_52, $459(%rip) + +LBB19_19: + WORD $0xfa80; BYTE $0x2e // cmpb $46, %dl + LONG $0x003d850f; WORD $0x0000 // jne LBB19_24, $61(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + WORD $0x394c; BYTE $0xea // cmpq %r13, %rdx + LONG $0x01a4830f; WORD $0x0000 // jae LBB19_51, $420(%rip) + LONG $0x44b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %eax + WORD $0xc604 // addb $-58, %al + WORD $0xf53c // cmpb $-11, %al + LONG $0x000f870f; WORD $0x0000 // ja LBB19_23, $15(%rip) + WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) + LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) + LONG $0x00018fe9; BYTE $0x00 // jmp LBB19_52, $399(%rip) + +LBB19_23: + LONG $0x00c845c7; WORD $0x0000; BYTE $0x00 // movl $0, $-56(%rbp) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + +LBB19_24: + WORD $0xd231 // xorl %edx, %edx + WORD $0xc985 // testl %ecx, %ecx + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x5589; BYTE $0xbc // movl %edx, $-68(%rbp) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x005d850f; WORD $0x0000 // jne LBB19_33, $93(%rip) + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0055850f; WORD $0x0000 // jne LBB19_33, $85(%rip) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0044830f; WORD $0x0000 // jae LBB19_31, $68(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xee // subl %r13d, %esi + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB19_28: + LONG $0x073c8041; BYTE $0x30 // cmpb $48, (%r15,%rax) + LONG $0x0029850f; WORD $0x0000 // jne LBB19_32, $41(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0xc9ff // decl %ecx + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0xffe7850f; WORD $0xffff // jne LBB19_28, $-25(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax + WORD $0xc084 // testb %al, %al + LONG $0x0144850f; WORD $0x0000 // jne LBB19_54, $324(%rip) + +LBB19_59: + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0x000173e9; BYTE $0x00 // jmp LBB19_60, $371(%rip) + +LBB19_31: + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + +LBB19_32: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + +LBB19_33: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x004c830f; WORD $0x0000 // jae LBB19_39, $76(%rip) + LONG $0x12f88341 // cmpl $18, %r8d + LONG $0x00428f0f; WORD $0x0000 // jg LBB19_39, $66(%rip) + LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d + + // .p2align 4, 0x90 +LBB19_36: + LONG $0x14b60f41; BYTE $0x07 // movzbl (%r15,%rax), %edx + WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x002a870f; WORD $0x0000 // ja LBB19_39, $42(%rip) + LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi + WORD $0x0144; BYTE $0xca // addl %r9d, %edx + LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 + WORD $0xc9ff // decl %ecx + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0011830f; WORD $0x0000 // jae LBB19_39, $17(%rip) + LONG $0x01508d41 // leal $1(%r8), %edx + LONG $0x12f88341 // cmpl $18, %r8d + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + LONG $0xffc48c0f; WORD $0xffff // jl LBB19_36, $-60(%rip) + +LBB19_39: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00c6830f; WORD $0x0000 // jae LBB19_53, $198(%rip) + LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x0030870f; WORD $0x0000 // ja LBB19_45, $48(%rip) + LONG $0xff558d49 // leaq $-1(%r13), %rdx + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB19_42: + WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx + LONG $0x0180840f; WORD $0x0000 // je LBB19_58, $384(%rip) + LONG $0x74b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %esi + WORD $0x7e8d; BYTE $0xd0 // leal $-48(%rsi), %edi + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0xffe1860f; WORD $0xffff // jbe LBB19_42, $-31(%rip) + LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) + +LBB19_45: + LONG $0xd6b60f40 // movzbl %sil, %edx + WORD $0xca83; BYTE $0x20 // orl $32, %edx + WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx + LONG $0x0075850f; WORD $0x0000 // jne LBB19_53, $117(%rip) + LONG $0x01788d48 // leaq $1(%rax), %rdi + LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + WORD $0x394c; BYTE $0xef // cmpq %r13, %rdi + LONG $0x0048830f; WORD $0x0000 // jae LBB19_51, $72(%rip) + LONG $0x34b60f41; BYTE $0x3f // movzbl (%r15,%rdi), %esi + WORD $0xfe83; BYTE $0x2d // cmpl $45, %esi + LONG $0x000f840f; WORD $0x0000 // je LBB19_49, $15(%rip) + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + WORD $0xfe83; BYTE $0x2b // cmpl $43, %esi + LONG $0x02a8850f; WORD $0x0000 // jne LBB19_86, $680(%rip) + +LBB19_49: + LONG $0x02c08348 // addq $2, %rax + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0x001b830f; WORD $0x0000 // jae LBB19_51, $27(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x2bfe8040 // cmpb $43, %sil + LONG $0xc7940f40 // sete %dil + LONG $0x3f048d44 // leal (%rdi,%rdi), %r8d + WORD $0xff41; BYTE $0xc8 // decl %r8d + LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi + LONG $0x000283e9; BYTE $0x00 // jmp LBB19_87, $643(%rip) + +LBB19_51: + WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) + LONG $0xff03c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rbx) + +LBB19_52: + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB19_53: + WORD $0xce89 // movl %ecx, %esi + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax + WORD $0xc084 // testb %al, %al + LONG $0xfebc840f; WORD $0xffff // je LBB19_59, $-324(%rip) + +LBB19_54: + WORD $0xf685 // testl %esi, %esi + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0x0025850f; WORD $0x0000 // jne LBB19_57, $37(%rip) + QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax + WORD $0x6348; BYTE $0xca // movslq %edx, %rcx + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x00e7890f; WORD $0x0000 // jns LBB19_68, $231(%rip) + WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00d8840f; WORD $0x0000 // je LBB19_68, $216(%rip) + +LBB19_57: + LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + +LBB19_60: + LONG $0x6ef9c1c4; BYTE $0xc4 // vmovq %r12, %xmm0 + QUAD $0xfffffc510562f9c5 // vpunpckldq $-943(%rip), %xmm0, %xmm0 /* LCPI19_0(%rip) */ + QUAD $0x00000000b045c748 // movq $0, $-80(%rbp) + QUAD $0xfffffc51055cf9c5 // vsubpd $-943(%rip), %xmm0, %xmm0 /* LCPI19_1(%rip) */ + LONG $0x0579e3c4; WORD $0x01c8 // vpermilpd $1, %xmm0, %xmm1 + LONG $0xc058f3c5 // vaddsd %xmm0, %xmm1, %xmm0 + LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0x34e8c148 // shrq $52, %rax + LONG $0x010d850f; WORD $0x0000 // jne LBB19_73, $269(%rip) + LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx + WORD $0xd089 // movl %edx, %eax + WORD $0xe8c1; BYTE $0x1f // shrl $31, %eax + LONG $0x3fe0c148 // shlq $63, %rax + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xc0458948 // movq %rax, $-64(%rbp) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x018a840f; WORD $0x0000 // je LBB19_81, $394(%rip) + WORD $0xf685 // testl %esi, %esi + LONG $0x0182840f; WORD $0x0000 // je LBB19_81, $386(%rip) + LONG $0x6ef9e1c4; BYTE $0xc0 // vmovq %rax, %xmm0 + WORD $0x468d; BYTE $0xff // leal $-1(%rsi), %eax + WORD $0xf883; BYTE $0x24 // cmpl $36, %eax + LONG $0x0040870f; WORD $0x0000 // ja LBB19_66, $64(%rip) + WORD $0xfe83; BYTE $0x17 // cmpl $23, %esi + LONG $0x0093820f; WORD $0x0000 // jb LBB19_69, $147(%rip) + WORD $0x468d; BYTE $0xea // leal $-22(%rsi), %eax + LONG $0x8b0d8d48; WORD $0x00e1; BYTE $0x00 // leaq $57739(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0x0459fbc5; BYTE $0xc1 // vmulsd (%rcx,%rax,8), %xmm0, %xmm0 + LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x000016b8; BYTE $0x00 // movl $22, %eax + LONG $0x000077e9; BYTE $0x00 // jmp LBB19_70, $119(%rip) + +LBB19_58: + LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) + WORD $0xce89 // movl %ecx, %esi + WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax + WORD $0xc084 // testb %al, %al + LONG $0xff1e850f; WORD $0xffff // jne LBB19_54, $-226(%rip) + LONG $0xfffdd5e9; BYTE $0xff // jmp LBB19_59, $-555(%rip) + +LBB19_66: + WORD $0xfe83; BYTE $0xea // cmpl $-22, %esi + LONG $0x008d820f; WORD $0x0000 // jb LBB19_73, $141(%rip) + WORD $0xdef7 // negl %esi + LONG $0x4c058d48; WORD $0x00e1; BYTE $0x00 // leaq $57676(%rip), %rax /* _P10_TAB(%rip) */ + LONG $0x045efbc5; BYTE $0xf0 // vdivsd (%rax,%rsi,8), %xmm0, %xmm0 + LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x0000d7e9; BYTE $0x00 // jmp LBB19_77, $215(%rip) + +LBB19_68: + LONG $0x6ef9c1c4; BYTE $0xc4 // vmovq %r12, %xmm0 + LONG $0xe1af0f4c // imulq %rcx, %r12 + QUAD $0xfffffb7c0562f9c5 // vpunpckldq $-1156(%rip), %xmm0, %xmm0 /* LCPI19_0(%rip) */ + QUAD $0xfffffb84055cf9c5 // vsubpd $-1148(%rip), %xmm0, %xmm0 /* LCPI19_1(%rip) */ + LONG $0x1063894c // movq %r12, $16(%rbx) + LONG $0x0579e3c4; WORD $0x01c8 // vpermilpd $1, %xmm0, %xmm1 + LONG $0xc058f3c5 // vaddsd %xmm0, %xmm1, %xmm0 + WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax + LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + LONG $0x084b8948 // movq %rcx, $8(%rbx) + LONG $0x000109e9; BYTE $0x00 // jmp LBB19_85, $265(%rip) + +LBB19_69: + WORD $0xf089 // movl %esi, %eax + +LBB19_70: + QUAD $0xfffffb68052ef9c5 // vucomisd $-1176(%rip), %xmm0 /* LCPI19_2(%rip) */ + LONG $0x002a870f; WORD $0x0000 // ja LBB19_73, $42(%rip) + QUAD $0xfffffb620d10fbc5 // vmovsd $-1182(%rip), %xmm1 /* LCPI19_3(%rip) */ + LONG $0xc82ef9c5 // vucomisd %xmm0, %xmm1 + LONG $0x0018870f; WORD $0x0000 // ja LBB19_73, $24(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0xd70d8d48; WORD $0x00e0; BYTE $0x00 // leaq $57559(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0x0459fbc5; BYTE $0xc1 // vmulsd (%rcx,%rax,8), %xmm0, %xmm0 + LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x000062e9; BYTE $0x00 // jmp LBB19_77, $98(%rip) + +LBB19_73: + LONG $0xa05d894c // movq %r11, $-96(%rbp) + LONG $0xc855894c // movq %r10, $-56(%rbp) + LONG $0xc04d8d48 // leaq $-64(%rbp), %rcx + WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi + LONG $0xa8758948 // movq %rsi, $-88(%rbp) + LONG $0xffdf90e8; BYTE $0xff // callq _atof_eisel_lemire64, $-8304(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x004c840f; WORD $0x0000 // je LBB19_79, $76(%rip) + LONG $0x00bc7d83 // cmpl $0, $-68(%rbp) + LONG $0x006d840f; WORD $0x0000 // je LBB19_80, $109(%rip) + WORD $0xff49; BYTE $0xc4 // incq %r12 + LONG $0xb04d8d48 // leaq $-80(%rbp), %rcx + WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi + LONG $0xa8758b48 // movq $-88(%rbp), %rsi + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0xffdf68e8; BYTE $0xff // callq _atof_eisel_lemire64, $-8344(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x0024840f; WORD $0x0000 // je LBB19_79, $36(%rip) + LONG $0x4d10fbc5; BYTE $0xb0 // vmovsd $-80(%rbp), %xmm1 + LONG $0x4510fbc5; BYTE $0xc0 // vmovsd $-64(%rbp), %xmm0 + LONG $0xc82ef9c5 // vucomisd %xmm0, %xmm1 + LONG $0x0010850f; WORD $0x0000 // jne LBB19_79, $16(%rip) + LONG $0x000a8a0f; WORD $0x0000 // jp LBB19_79, $10(%rip) + +LBB19_77: + LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq %xmm0, %rax + LONG $0x00002fe9; BYTE $0x00 // jmp LBB19_81, $47(%rip) + +LBB19_79: + WORD $0x8b49; BYTE $0x06 // movq (%r14), %rax + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + LONG $0xa04d8b48 // movq $-96(%rbp), %rcx + LONG $0xffe8a0e8; BYTE $0xff // callq _atof_native, $-5984(%rip) + LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq %xmm0, %rax + LONG $0x000009e9; BYTE $0x00 // jmp LBB19_82, $9(%rip) + +LBB19_80: + LONG $0xc0458b48 // movq $-64(%rbp), %rax + +LBB19_81: + LONG $0x6ef9e1c4; BYTE $0xc0 // vmovq %rax, %xmm0 + +LBB19_82: + QUAD $0x000000000000b948; WORD $0x8000 // movabsq $-9223372036854775808, %rcx + WORD $0xff48; BYTE $0xc9 // decq %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + QUAD $0x000000000000b848; WORD $0x7ff0 // movabsq $9218868437227405312, %rax + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x0007850f; WORD $0x0000 // jne LBB19_84, $7(%rip) + LONG $0xf803c748; WORD $0xffff; BYTE $0xff // movq $-8, (%rbx) + +LBB19_84: + LONG $0x4311fbc5; BYTE $0x08 // vmovsd %xmm0, $8(%rbx) + +LBB19_85: + WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) + LONG $0xfffd8de9; BYTE $0xff // jmp LBB19_52, $-627(%rip) + +LBB19_86: + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + +LBB19_87: + LONG $0xc6c68040 // addb $-58, %sil + LONG $0xf6fe8040 // cmpb $-10, %sil + LONG $0xfadb820f; WORD $0xffff // jb LBB19_5, $-1317(%rip) + WORD $0xf631 // xorl %esi, %esi + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0035830f; WORD $0x0000 // jae LBB19_93, $53(%rip) + WORD $0xf631 // xorl %esi, %esi + +LBB19_90: + LONG $0x0cb60f45; BYTE $0x07 // movzbl (%r15,%rax), %r9d + LONG $0xd0798d41 // leal $-48(%r9), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x0020870f; WORD $0x0000 // ja LBB19_93, $32(%rip) + LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi + WORD $0x3c8d; BYTE $0xb6 // leal (%rsi,%rsi,4), %edi + LONG $0x797c8d41; BYTE $0xd0 // leal $-48(%r9,%rdi,2), %edi + WORD $0x4c0f; BYTE $0xf7 // cmovll %edi, %esi + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0xffd0850f; WORD $0xffff // jne LBB19_90, $-48(%rip) + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + +LBB19_93: + LONG $0xf0af0f41 // imull %r8d, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0xfffd81e9; BYTE $0xff // jmp LBB19_60, $-639(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_vsigned: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + LONG $0x4211f8c5; BYTE $0x08 // vmovups %xmm0, $8(%rdx) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + LONG $0x184a8948 // movq %rcx, $24(%rdx) + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x0046830f; WORD $0x0000 // jae LBB20_1, $70(%rip) + LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl + LONG $0x0018850f; WORD $0x0000 // jne LBB20_5, $24(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x0026830f; WORD $0x0000 // jae LBB20_1, $38(%rip) + LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + +LBB20_5: + WORD $0x798d; BYTE $0xc6 // leal $-58(%rcx), %edi + LONG $0xf5ff8040 // cmpb $-11, %dil + LONG $0x001a870f; WORD $0x0000 // ja LBB20_7, $26(%rip) + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfe02c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_1: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_7: + WORD $0xf980; BYTE $0x30 // cmpb $48, %cl + LONG $0x0032850f; WORD $0x0000 // jne LBB20_12, $50(%rip) + LONG $0x01508d4c // leaq $1(%rax), %r10 + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x007f830f; WORD $0x0000 // jae LBB20_11, $127(%rip) + LONG $0x3cb60f43; BYTE $0x11 // movzbl (%r9,%r10), %edi + WORD $0xc783; BYTE $0xd2 // addl $-46, %edi + WORD $0xff83; BYTE $0x37 // cmpl $55, %edi + LONG $0x006e870f; WORD $0x0000 // ja LBB20_11, $110(%rip) + QUAD $0x000000800001b948; WORD $0x0080 // movabsq $36028797027352577, %rcx + LONG $0xf9a30f48 // btq %rdi, %rcx + LONG $0x005a830f; WORD $0x0000 // jae LBB20_11, $90(%rip) + +LBB20_12: + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xd0470f4c // cmovaq %rax, %r10 + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB20_13: + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x007d830f; WORD $0x0000 // jae LBB20_23, $125(%rip) + LONG $0x3cbe0f49; BYTE $0x01 // movsbq (%r9,%rax), %rdi + WORD $0x5f8d; BYTE $0xd0 // leal $-48(%rdi), %ebx + WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl + LONG $0x0033870f; WORD $0x0000 // ja LBB20_18, $51(%rip) + LONG $0x0ac96b48 // imulq $10, %rcx, %rcx + LONG $0x0013800f; WORD $0x0000 // jo LBB20_17, $19(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0xc783; BYTE $0xd0 // addl $-48, %edi + LONG $0xf8af0f49 // imulq %r8, %rdi + WORD $0x0148; BYTE $0xf9 // addq %rdi, %rcx + LONG $0xffc9810f; WORD $0xffff // jno LBB20_13, $-55(%rip) + +LBB20_17: + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfb02c748; WORD $0xffff; BYTE $0xff // movq $-5, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_11: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_18: + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x002d830f; WORD $0x0000 // jae LBB20_22, $45(%rip) + LONG $0x3cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %edi + WORD $0xff83; BYTE $0x2e // cmpl $46, %edi + LONG $0x0012840f; WORD $0x0000 // je LBB20_25, $18(%rip) + WORD $0xff83; BYTE $0x45 // cmpl $69, %edi + LONG $0x0009840f; WORD $0x0000 // je LBB20_25, $9(%rip) + WORD $0xff83; BYTE $0x65 // cmpl $101, %edi + LONG $0x000d850f; WORD $0x0000 // jne LBB20_22, $13(%rip) + +LBB20_25: + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfa02c748; WORD $0xffff; BYTE $0xff // movq $-6, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_22: + WORD $0x8949; BYTE $0xc2 // movq %rax, %r10 + +LBB20_23: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + LONG $0x104a8948 // movq %rcx, $16(%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + + // .p2align 4, 0x90 +_vunsigned: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0x08778b4c // movq $8(%rdi), %r14 + LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + LONG $0x4211f8c5; BYTE $0x08 // vmovups %xmm0, $8(%rdx) + WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax + LONG $0x18428948 // movq %rax, $24(%rdx) + WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx + LONG $0x001c830f; WORD $0x0000 // jae LBB21_1, $28(%rip) + LONG $0x04b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %eax + WORD $0x2d3c // cmpb $45, %al + LONG $0x001e850f; WORD $0x0000 // jne LBB21_4, $30(%rip) + +LBB21_3: + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfa00c749; WORD $0xffff; BYTE $0xff // movq $-6, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_1: + WORD $0x894c; BYTE $0x36 // movq %r14, (%rsi) + LONG $0xff00c749; WORD $0xffff; BYTE $0xff // movq $-1, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_4: + WORD $0x508d; BYTE $0xc6 // leal $-58(%rax), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB21_6, $15(%rip) + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfe00c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_6: + WORD $0x303c // cmpb $48, %al + LONG $0x0026850f; WORD $0x0000 // jne LBB21_10, $38(%rip) + LONG $0x44b60f41; WORD $0x0109 // movzbl $1(%r9,%rcx), %eax + WORD $0xc083; BYTE $0xd2 // addl $-46, %eax + WORD $0xf883; BYTE $0x37 // cmpl $55, %eax + LONG $0x00c0870f; WORD $0x0000 // ja LBB21_9, $192(%rip) + QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx + LONG $0xc2a30f48 // btq %rax, %rdx + LONG $0x00ac830f; WORD $0x0000 // jae LBB21_9, $172(%rip) + +LBB21_10: + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0xd6470f4d // cmovaq %r14, %r10 + WORD $0xc031 // xorl %eax, %eax + LONG $0x000abb41; WORD $0x0000 // movl $10, %r11d + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB21_11: + WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx + LONG $0x007f830f; WORD $0x0000 // jae LBB21_22, $127(%rip) + LONG $0x1cbe0f41; BYTE $0x09 // movsbl (%r9,%rcx), %ebx + WORD $0x538d; BYTE $0xd0 // leal $-48(%rbx), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x0042870f; WORD $0x0000 // ja LBB21_17, $66(%rip) + WORD $0xf749; BYTE $0xe3 // mulq %r11 + LONG $0x0027800f; WORD $0x0000 // jo LBB21_16, $39(%rip) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0xc383; BYTE $0xd0 // addl $-48, %ebx + WORD $0xff31 // xorl %edi, %edi + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0xc7920f40 // setb %dil + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + WORD $0xf748; BYTE $0xda // negq %rdx + WORD $0x3148; BYTE $0xd7 // xorq %rdx, %rdi + LONG $0x0009850f; WORD $0x0000 // jne LBB21_16, $9(%rip) + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffb6890f; WORD $0xffff // jns LBB21_11, $-74(%rip) + +LBB21_16: + WORD $0xff48; BYTE $0xc9 // decq %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfb00c749; WORD $0xffff; BYTE $0xff // movq $-5, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_17: + WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx + LONG $0x0020830f; WORD $0x0000 // jae LBB21_21, $32(%rip) + LONG $0x14b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %edx + WORD $0xfa83; BYTE $0x2e // cmpl $46, %edx + LONG $0xff0e840f; WORD $0xffff // je LBB21_3, $-242(%rip) + WORD $0xfa83; BYTE $0x45 // cmpl $69, %edx + LONG $0xff05840f; WORD $0xffff // je LBB21_3, $-251(%rip) + WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx + LONG $0xfefc840f; WORD $0xffff // je LBB21_3, $-260(%rip) + +LBB21_21: + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + +LBB21_22: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + LONG $0x10408949 // movq %rax, $16(%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_9: + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + BYTE $0x00 // .p2align 4, 0x00 + +LCPI22_0: + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000005 // .quad 5 + + // .p2align 4, 0x90 +_skip_array: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI22_0(%rip) */ + LONG $0x0011f8c5 // vmovups %xmm0, (%rax) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0x00000ee9; BYTE $0x00 // jmp _fsm_exec, $14(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_fsm_exec: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x28ec8348 // subq $40, %rsp + LONG $0xb84d8948 // movq %rcx, $-72(%rbp) + LONG $0x003f8348 // cmpq $0, (%rdi) + LONG $0x03b1840f; WORD $0x0000 // je LBB23_2, $945(%rip) + WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0xd0758948 // movq %rsi, $-48(%rbp) + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + LONG $0xc8558948 // movq %rdx, $-56(%rbp) + LONG $0x000033e9; BYTE $0x00 // jmp LBB23_7, $51(%rip) + +LBB23_3: + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x000006b8; BYTE $0x00 // movl $6, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0x03a78f0f; WORD $0x0000 // jg LBB23_62, $935(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +LBB23_4: + LONG $0x01518d48 // leaq $1(%rcx), %rdx + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + +LBB23_5: + LONG $0xd7448949; BYTE $0x08 // movq %rax, $8(%r15,%rdx,8) + +LBB23_6: + LONG $0x003f8349 // cmpq $0, (%r15) + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + LONG $0x035c840f; WORD $0x0000 // je LBB23_54, $860(%rip) + +LBB23_7: + LONG $0xd06d8b4c // movq $-48(%rbp), %r13 + LONG $0x007d8b49 // movq (%r13), %rdi + LONG $0x08758b49 // movq $8(%r13), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffee60e8; BYTE $0xff // callq _advance_ns, $-4512(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x0348840f; WORD $0x0000 // je LBB23_2, $840(%rip) + LONG $0xfffe8349 // cmpq $-1, %r14 + LONG $0x0007850f; WORD $0x0000 // jne LBB23_10, $7(%rip) + LONG $0x24348b4d // movq (%r12), %r14 + WORD $0xff49; BYTE $0xce // decq %r14 + +LBB23_10: + WORD $0xbe0f; BYTE $0xf0 // movsbl %al, %esi + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + LONG $0xcf3c8b41 // movl (%r15,%rcx,8), %edi + WORD $0xcfff // decl %edi + WORD $0xff83; BYTE $0x05 // cmpl $5, %edi + LONG $0x0027870f; WORD $0x0000 // ja LBB23_14, $39(%rip) + LONG $0x7b1d8d48; WORD $0x0004; BYTE $0x00 // leaq $1147(%rip), %rbx /* LJTI23_0(%rip) */ + LONG $0xbb3c6348 // movslq (%rbx,%rdi,4), %rdi + WORD $0x0148; BYTE $0xdf // addq %rbx, %rdi + JMP DI + +LBB23_12: + WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi + LONG $0x01a8840f; WORD $0x0000 // je LBB23_35, $424(%rip) + WORD $0xfe83; BYTE $0x5d // cmpl $93, %esi + LONG $0x016c840f; WORD $0x0000 // je LBB23_32, $364(%rip) + LONG $0x000310e9; BYTE $0x00 // jmp LBB23_58, $784(%rip) + +LBB23_14: + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi + LONG $0x0099860f; WORD $0x0000 // jbe LBB23_26, $153(%rip) + LONG $0x0002d7e9; BYTE $0x00 // jmp LBB23_54, $727(%rip) + +LBB23_15: + WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi + LONG $0x0146840f; WORD $0x0000 // je LBB23_32, $326(%rip) + WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi + LONG $0x02e6850f; WORD $0x0000 // jne LBB23_58, $742(%rip) + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0xff3b8e0f; WORD $0xffff // jle LBB23_4, $-197(%rip) + LONG $0x0002dbe9; BYTE $0x00 // jmp LBB23_62, $731(%rip) + +LBB23_18: + WORD $0x223c // cmpb $34, %al + LONG $0x02c7850f; WORD $0x0000 // jne LBB23_58, $711(%rip) + QUAD $0x00000004cf04c749 // movq $4, (%r15,%rcx,8) + LONG $0x241c8b49 // movq (%r12), %rbx + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + +LBB23_20: + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xc0558d48 // leaq $-64(%rbp), %rdx + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + LONG $0xfff0bfe8; BYTE $0xff // callq _advance_string, $-3905(%rip) + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0107890f; WORD $0x0000 // jns LBB23_33, $263(%rip) + LONG $0xc0458b48 // movq $-64(%rbp), %rax + LONG $0x000107e9; BYTE $0x00 // jmp LBB23_34, $263(%rip) + +LBB23_22: + WORD $0x3a3c // cmpb $58, %al + LONG $0x028b850f; WORD $0x0000 // jne LBB23_58, $651(%rip) + WORD $0xc031 // xorl %eax, %eax + LONG $0xfffef5e9; BYTE $0xff // jmp LBB23_5, $-267(%rip) + +LBB23_24: + WORD $0x5d3c // cmpb $93, %al + LONG $0x00d3840f; WORD $0x0000 // je LBB23_32, $211(%rip) + QUAD $0x00000001cf04c749 // movq $1, (%r15,%rcx,8) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi + LONG $0x0243870f; WORD $0x0000 // ja LBB23_54, $579(%rip) + +LBB23_26: + WORD $0xf189 // movl %esi, %ecx + LONG $0xbe158d48; WORD $0x0003; BYTE $0x00 // leaq $958(%rip), %rdx /* LJTI23_1(%rip) */ + LONG $0x8a0c6348 // movslq (%rdx,%rcx,4), %rcx + WORD $0x0148; BYTE $0xd1 // addq %rdx, %rcx + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + JMP CX + +LBB23_27: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx + LONG $0xff6b8d4c // leaq $-1(%rbx), %r13 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi + WORD $0x014c; BYTE $0xef // addq %r13, %rdi + LONG $0x08708b48 // movq $8(%rax), %rsi + WORD $0x294c; BYTE $0xee // subq %r13, %rsi + LONG $0x0006e1e8; BYTE $0x00 // callq _do_skip_number, $1761(%rip) + LONG $0xff488d48 // leaq $-1(%rax), %rcx + LONG $0xfec2c748; WORD $0xffff; BYTE $0xff // movq $-2, %rdx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xd1490f48 // cmovnsq %rcx, %rdx + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xe8480f4c // cmovsq %rax, %r13 + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0x24148949 // movq %rdx, (%r12) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfe6c890f; WORD $0xffff // jns LBB23_6, $-404(%rip) + LONG $0x0001dfe9; BYTE $0x00 // jmp LBB23_55, $479(%rip) + +LBB23_28: + WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi + LONG $0x003f840f; WORD $0x0000 // je LBB23_32, $63(%rip) + WORD $0xfe83; BYTE $0x22 // cmpl $34, %esi + LONG $0x01df850f; WORD $0x0000 // jne LBB23_58, $479(%rip) + QUAD $0x00000002cf04c749 // movq $2, (%r15,%rcx,8) + LONG $0x241c8b49 // movq (%r12), %rbx + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xc0558d48 // leaq $-64(%rbp), %rdx + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + LONG $0xffefd7e8; BYTE $0xff // callq _advance_string, $-4137(%rip) + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0052890f; WORD $0x0000 // jns LBB23_37, $82(%rip) + LONG $0xc0458b48 // movq $-64(%rbp), %rax + LONG $0x000052e9; BYTE $0x00 // jmp LBB23_38, $82(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +LBB23_32: + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xfe1d850f; WORD $0xffff // jne LBB23_7, $-483(%rip) + LONG $0x000183e9; BYTE $0x00 // jmp LBB23_55, $387(%rip) + +LBB23_33: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 + +LBB23_34: + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0x24048949 // movq %rax, (%r12) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfdf1890f; WORD $0xffff // jns LBB23_6, $-527(%rip) + LONG $0x000164e9; BYTE $0x00 // jmp LBB23_55, $356(%rip) + +LBB23_35: + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0x01758f0f; WORD $0x0000 // jg LBB23_62, $373(%rip) + WORD $0xc031 // xorl %eax, %eax + LONG $0xfffdc9e9; BYTE $0xff // jmp LBB23_4, $-567(%rip) + +LBB23_37: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 + +LBB23_38: + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0x24048949 // movq %rax, (%r12) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x0136880f; WORD $0x0000 // js LBB23_55, $310(%rip) + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x000004b8; BYTE $0x00 // movl $4, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0xfd9a8e0f; WORD $0xffff // jle LBB23_4, $-614(%rip) + LONG $0x00013ae9; BYTE $0x00 // jmp LBB23_62, $314(%rip) + +LBB23_40: + LONG $0x241c8b49 // movq (%r12), %rbx + LONG $0xd07d8b48 // movq $-48(%rbp), %rdi + LONG $0xfffe69e9; BYTE $0xff // jmp LBB23_20, $-407(%rip) + +LBB23_41: + LONG $0x242c8b4d // movq (%r12), %r13 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi + WORD $0x014c; BYTE $0xef // addq %r13, %rdi + LONG $0x08708b48 // movq $8(%rax), %rsi + WORD $0x294c; BYTE $0xee // subq %r13, %rsi + LONG $0x0005bee8; BYTE $0x00 // callq _do_skip_number, $1470(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0126880f; WORD $0x0000 // js LBB23_66, $294(%rip) + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + LONG $0x24048949 // movq %rax, (%r12) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfd648f0f; WORD $0xffff // jg LBB23_6, $-668(%rip) + LONG $0x000127e9; BYTE $0x00 // jmp LBB23_68, $295(%rip) + +LBB23_43: + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x000005b8; BYTE $0x00 // movl $5, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0xfd3b8e0f; WORD $0xffff // jle LBB23_4, $-709(%rip) + LONG $0x0000dbe9; BYTE $0x00 // jmp LBB23_62, $219(%rip) + +LBB23_44: + LONG $0x24048b49 // movq (%r12), %rax + LONG $0xd0758b48 // movq $-48(%rbp), %rsi + LONG $0x084e8b48 // movq $8(%rsi), %rcx + LONG $0xfc518d48 // leaq $-4(%rcx), %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0x00ce870f; WORD $0x0000 // ja LBB23_64, $206(%rip) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x148b; BYTE $0x01 // movl (%rcx,%rax), %edx + LONG $0x6c61fa81; WORD $0x6573 // cmpl $1702063201, %edx + LONG $0x0198850f; WORD $0x0000 // jne LBB23_78, $408(%rip) + LONG $0x04488d48 // leaq $4(%rax), %rcx + LONG $0x240c8949 // movq %rcx, (%r12) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfd098f0f; WORD $0xffff // jg LBB23_6, $-759(%rip) + LONG $0x00006ae9; BYTE $0x00 // jmp LBB23_52, $106(%rip) + +LBB23_47: + LONG $0x24048b49 // movq (%r12), %rax + LONG $0xd0758b48 // movq $-48(%rbp), %rsi + LONG $0x084e8b48 // movq $8(%rsi), %rcx + LONG $0xfd518d48 // leaq $-3(%rcx), %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0x008d870f; WORD $0x0000 // ja LBB23_64, $141(%rip) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + QUAD $0x6c6c756eff017c81 // cmpl $1819047278, $-1(%rcx,%rax) + LONG $0x002f840f; WORD $0x0000 // je LBB23_51, $47(%rip) + LONG $0x0000a5e9; BYTE $0x00 // jmp LBB23_69, $165(%rip) + +LBB23_49: + LONG $0x24048b49 // movq (%r12), %rax + LONG $0xd0758b48 // movq $-48(%rbp), %rsi + LONG $0x084e8b48 // movq $8(%rsi), %rcx + LONG $0xfd518d48 // leaq $-3(%rcx), %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0x005e870f; WORD $0x0000 // ja LBB23_64, $94(%rip) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + QUAD $0x65757274ff017c81 // cmpl $1702195828, $-1(%rcx,%rax) + LONG $0x00ce850f; WORD $0x0000 // jne LBB23_73, $206(%rip) + +LBB23_51: + LONG $0x03488d48 // leaq $3(%rax), %rcx + LONG $0x240c8949 // movq %rcx, (%r12) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfc9a8f0f; WORD $0xffff // jg LBB23_6, $-870(%rip) + +LBB23_52: + WORD $0xff48; BYTE $0xc8 // decq %rax + +LBB23_54: + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0x000007e9; BYTE $0x00 // jmp LBB23_55, $7(%rip) + +LBB23_2: + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + +LBB23_55: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB23_58: + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB23_55, $-30(%rip) + +LBB23_62: + LONG $0xf9c5c749; WORD $0xffff; BYTE $0xff // movq $-7, %r13 + LONG $0xffffd6e9; BYTE $0xff // jmp LBB23_55, $-42(%rip) + +LBB23_64: + LONG $0x240c8949 // movq %rcx, (%r12) + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + LONG $0xffffc6e9; BYTE $0xff // jmp LBB23_55, $-58(%rip) + +LBB23_66: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0xc5 // addq %rax, %r13 + LONG $0x242c894d // movq %r13, (%r12) + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xffffb0e9; BYTE $0xff // jmp LBB23_55, $-80(%rip) + +LBB23_68: + WORD $0xff49; BYTE $0xcd // decq %r13 + LONG $0xffffa8e9; BYTE $0xff // jmp LBB23_55, $-88(%rip) + +LBB23_69: + LONG $0xff508d48 // leaq $-1(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xff017c80; BYTE $0x6e // cmpb $110, $-1(%rcx,%rax) + LONG $0xff8e850f; WORD $0xffff // jne LBB23_55, $-114(%rip) + LONG $0x24048949 // movq %rax, (%r12) + LONG $0x75013c80 // cmpb $117, (%rcx,%rax) + LONG $0xff80850f; WORD $0xffff // jne LBB23_55, $-128(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) + LONG $0xff6d850f; WORD $0xffff // jne LBB23_55, $-147(%rip) + LONG $0x02508d48 // leaq $2(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x02017c80; BYTE $0x6c // cmpb $108, $2(%rcx,%rax) + LONG $0xff5a850f; WORD $0xffff // jne LBB23_55, $-166(%rip) + LONG $0x00004ee9; BYTE $0x00 // jmp LBB23_77, $78(%rip) + +LBB23_73: + LONG $0xff508d48 // leaq $-1(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xff017c80; BYTE $0x74 // cmpb $116, $-1(%rcx,%rax) + LONG $0xff3b850f; WORD $0xffff // jne LBB23_55, $-197(%rip) + LONG $0x24048949 // movq %rax, (%r12) + LONG $0x72013c80 // cmpb $114, (%rcx,%rax) + LONG $0xff2d850f; WORD $0xffff // jne LBB23_55, $-211(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x01017c80; BYTE $0x75 // cmpb $117, $1(%rcx,%rax) + LONG $0xff1a850f; WORD $0xffff // jne LBB23_55, $-230(%rip) + LONG $0x02508d48 // leaq $2(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x02017c80; BYTE $0x65 // cmpb $101, $2(%rcx,%rax) + LONG $0xff07850f; WORD $0xffff // jne LBB23_55, $-249(%rip) + +LBB23_77: + LONG $0x03c08348 // addq $3, %rax + LONG $0x24048949 // movq %rax, (%r12) + LONG $0xfffefae9; BYTE $0xff // jmp LBB23_55, $-262(%rip) + +LBB23_78: + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + WORD $0xfa80; BYTE $0x61 // cmpb $97, %dl + LONG $0xfeea850f; WORD $0xffff // jne LBB23_55, $-278(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) + LONG $0xfed7850f; WORD $0xffff // jne LBB23_55, $-297(%rip) + LONG $0x02508d48 // leaq $2(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x02017c80; BYTE $0x73 // cmpb $115, $2(%rcx,%rax) + LONG $0xfec4850f; WORD $0xffff // jne LBB23_55, $-316(%rip) + LONG $0x03508d48 // leaq $3(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x03017c80; BYTE $0x65 // cmpb $101, $3(%rcx,%rax) + LONG $0xfeb1850f; WORD $0xffff // jne LBB23_55, $-335(%rip) + LONG $0x04c08348 // addq $4, %rax + LONG $0x24048949 // movq %rax, (%r12) + LONG $0xfffea4e9; BYTE $0xff // jmp LBB23_55, $-348(%rip) + BYTE $0x90 // .p2align 2, 0x90 + + // .set L23_0_set_12, LBB23_12-LJTI23_0 + // .set L23_0_set_15, LBB23_15-LJTI23_0 + // .set L23_0_set_18, LBB23_18-LJTI23_0 + // .set L23_0_set_22, LBB23_22-LJTI23_0 + // .set L23_0_set_24, LBB23_24-LJTI23_0 + // .set L23_0_set_28, LBB23_28-LJTI23_0 +LJTI23_0: + LONG $0xfffffb8e // .long L23_0_set_12 + LONG $0xfffffbbd // .long L23_0_set_15 + LONG $0xfffffbe6 // .long L23_0_set_18 + LONG $0xfffffc22 // .long L23_0_set_22 + LONG $0xfffffc31 // .long L23_0_set_24 + LONG $0xfffffcc4 // .long L23_0_set_28 + + // .set L23_1_set_55, LBB23_55-LJTI23_1 + // .set L23_1_set_54, LBB23_54-LJTI23_1 + // .set L23_1_set_40, LBB23_40-LJTI23_1 + // .set L23_1_set_41, LBB23_41-LJTI23_1 + // .set L23_1_set_27, LBB23_27-LJTI23_1 + // .set L23_1_set_43, LBB23_43-LJTI23_1 + // .set L23_1_set_44, LBB23_44-LJTI23_1 + // .set L23_1_set_47, LBB23_47-LJTI23_1 + // .set L23_1_set_49, LBB23_49-LJTI23_1 + // .set L23_1_set_3, LBB23_3-LJTI23_1 +LJTI23_1: + LONG $0xfffffe8b // .long L23_1_set_55 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffd6f // .long L23_1_set_40 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffd7c // .long L23_1_set_41 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffdb4 // .long L23_1_set_43 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffdce // .long L23_1_set_44 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe0f // .long L23_1_set_47 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe3e // .long L23_1_set_49 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffaed // .long L23_1_set_3 + LONG $0x00000000 // .p2align 4, 0x00 + +LCPI24_0: + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000006 // .quad 6 + + // .p2align 4, 0x90 +_skip_object: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI24_0(%rip) */ + LONG $0x0011f8c5 // vmovups %xmm0, (%rax) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0xfff88ee9; BYTE $0xff // jmp _fsm_exec, $-1906(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_skip_string: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + LONG $0x10ec8348 // subq $16, %rsp + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b48; BYTE $0x1e // movq (%rsi), %rbx + LONG $0xe8558d48 // leaq $-24(%rbp), %rdx + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xffea60e8; BYTE $0xff // callq _advance_string, $-5536(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0009890f; WORD $0x0000 // jns LBB25_1, $9(%rip) + LONG $0xe84d8b48 // movq $-24(%rbp), %rcx + LONG $0x000009e9; BYTE $0x00 // jmp LBB25_3, $9(%rip) + +LBB25_1: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + +LBB25_3: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +_skip_negative: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b48; BYTE $0x1e // movq (%rsi), %rbx + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0x08778b48 // movq $8(%rdi), %rsi + WORD $0x2948; BYTE $0xde // subq %rbx, %rsi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0x0000aee8; BYTE $0x00 // callq _do_skip_number, $174(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x000e880f; WORD $0x0000 // js LBB26_1, $14(%rip) + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + WORD $0xff48; BYTE $0xcb // decq %rbx + LONG $0x000010e9; BYTE $0x00 // jmp LBB26_3, $16(%rip) + +LBB26_1: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) + LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx + +LBB26_3: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI27_0: + QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' + +LCPI27_1: + QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' + +LCPI27_2: + QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0' + +LCPI27_3: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI27_4: + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + +LCPI27_5: + QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................' + +LCPI27_6: + QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE' + + // .p2align 4, 0x90 +_do_skip_number: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0235840f; WORD $0x0000 // je LBB27_1, $565(%rip) + WORD $0x3f80; BYTE $0x30 // cmpb $48, (%rdi) + LONG $0x0033850f; WORD $0x0000 // jne LBB27_6, $51(%rip) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x01fe8348 // cmpq $1, %rsi + LONG $0x02b8840f; WORD $0x0000 // je LBB27_55, $696(%rip) + LONG $0x014fb60f // movzbl $1(%rdi), %ecx + WORD $0xc183; BYTE $0xd2 // addl $-46, %ecx + WORD $0xf983; BYTE $0x37 // cmpl $55, %ecx + LONG $0x02a8870f; WORD $0x0000 // ja LBB27_55, $680(%rip) + QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx + LONG $0xcaa30f48 // btq %rcx, %rdx + LONG $0x0294830f; WORD $0x0000 // jae LBB27_55, $660(%rip) + +LBB27_6: + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0x02f3820f; WORD $0x0000 // jb LBB27_7, $755(%rip) + LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 + WORD $0xc031 // xorl %eax, %eax + QUAD $0xffffff27056f79c5 // vmovdqa $-217(%rip), %xmm8 /* LCPI27_0(%rip) */ + QUAD $0xffffff2f0d6f79c5 // vmovdqa $-209(%rip), %xmm9 /* LCPI27_1(%rip) */ + QUAD $0xffffff37156f79c5 // vmovdqa $-201(%rip), %xmm10 /* LCPI27_2(%rip) */ + QUAD $0xffffff3f1d6ff9c5 // vmovdqa $-193(%rip), %xmm3 /* LCPI27_3(%rip) */ + QUAD $0xffffff47256ff9c5 // vmovdqa $-185(%rip), %xmm4 /* LCPI27_4(%rip) */ + QUAD $0xffffff4f2d6ff9c5 // vmovdqa $-177(%rip), %xmm5 /* LCPI27_5(%rip) */ + QUAD $0xffffff57356ff9c5 // vmovdqa $-169(%rip), %xmm6 /* LCPI27_6(%rip) */ + LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB27_9: + LONG $0x3c6ffac5; BYTE $0x07 // vmovdqu (%rdi,%rax), %xmm7 + LONG $0xc774b9c5 // vpcmpeqb %xmm7, %xmm8, %xmm0 + LONG $0xcf74b1c5 // vpcmpeqb %xmm7, %xmm9, %xmm1 + LONG $0xc0ebf1c5 // vpor %xmm0, %xmm1, %xmm0 + LONG $0xcffca9c5 // vpaddb %xmm7, %xmm10, %xmm1 + LONG $0xd3daf1c5 // vpminub %xmm3, %xmm1, %xmm2 + LONG $0xca74f1c5 // vpcmpeqb %xmm2, %xmm1, %xmm1 + LONG $0xd4dbc1c5 // vpand %xmm4, %xmm7, %xmm2 + LONG $0xd674e9c5 // vpcmpeqb %xmm6, %xmm2, %xmm2 + LONG $0xfd74c1c5 // vpcmpeqb %xmm5, %xmm7, %xmm7 + LONG $0xdfd7f9c5 // vpmovmskb %xmm7, %ebx + LONG $0xf2d779c5 // vpmovmskb %xmm2, %r14d + LONG $0xd8d779c5 // vpmovmskb %xmm0, %r11d + LONG $0xd7ebe9c5 // vpor %xmm7, %xmm2, %xmm2 + LONG $0xc0ebe9c5 // vpor %xmm0, %xmm2, %xmm0 + LONG $0xc1ebf9c5 // vpor %xmm1, %xmm0, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx + LONG $0x0014840f; WORD $0x0000 // je LBB27_11, $20(%rip) + LONG $0xffffffba; BYTE $0xff // movl $-1, %edx + WORD $0xe2d3 // shll %cl, %edx + WORD $0xd2f7 // notl %edx + WORD $0xd321 // andl %edx, %ebx + WORD $0x2141; BYTE $0xd6 // andl %edx, %r14d + WORD $0x2144; BYTE $0xda // andl %r11d, %edx + WORD $0x8941; BYTE $0xd3 // movl %edx, %r11d + +LBB27_11: + WORD $0x538d; BYTE $0xff // leal $-1(%rbx), %edx + WORD $0xda21 // andl %ebx, %edx + LONG $0x0206850f; WORD $0x0000 // jne LBB27_12, $518(%rip) + LONG $0xff568d41 // leal $-1(%r14), %edx + WORD $0x2144; BYTE $0xf2 // andl %r14d, %edx + LONG $0x01f9850f; WORD $0x0000 // jne LBB27_12, $505(%rip) + LONG $0xff538d41 // leal $-1(%r11), %edx + WORD $0x2144; BYTE $0xda // andl %r11d, %edx + LONG $0x01ec850f; WORD $0x0000 // jne LBB27_12, $492(%rip) + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x0013840f; WORD $0x0000 // je LBB27_19, $19(%rip) + WORD $0xbc0f; BYTE $0xdb // bsfl %ebx, %ebx + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x01ed850f; WORD $0x0000 // jne LBB27_56, $493(%rip) + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + +LBB27_19: + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x0014840f; WORD $0x0000 // je LBB27_22, $20(%rip) + LONG $0xdebc0f41 // bsfl %r14d, %ebx + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x01d0850f; WORD $0x0000 // jne LBB27_56, $464(%rip) + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x8949; BYTE $0xd9 // movq %rbx, %r9 + +LBB27_22: + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x0014840f; WORD $0x0000 // je LBB27_25, $20(%rip) + LONG $0xdbbc0f41 // bsfl %r11d, %ebx + LONG $0xfffa8349 // cmpq $-1, %r10 + LONG $0x01b3850f; WORD $0x0000 // jne LBB27_56, $435(%rip) + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x8949; BYTE $0xda // movq %rbx, %r10 + +LBB27_25: + WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx + LONG $0x00b9850f; WORD $0x0000 // jne LBB27_57, $185(%rip) + LONG $0xf0c78349 // addq $-16, %r15 + LONG $0x10c08348 // addq $16, %rax + LONG $0x0fff8349 // cmpq $15, %r15 + LONG $0xff04870f; WORD $0xffff // ja LBB27_9, $-252(%rip) + LONG $0x070c8d48 // leaq (%rdi,%rax), %rcx + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x00a0840f; WORD $0x0000 // je LBB27_41, $160(%rip) + +LBB27_28: + LONG $0x391c8d4e // leaq (%rcx,%r15), %r11 + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + WORD $0x2948; BYTE $0xfe // subq %rdi, %rsi + WORD $0xc031 // xorl %eax, %eax + LONG $0x9d358d4c; WORD $0x0001; BYTE $0x00 // leaq $413(%rip), %r14 /* LJTI27_0(%rip) */ + LONG $0x000028e9; BYTE $0x00 // jmp LBB27_29, $40(%rip) + +LBB27_31: + WORD $0xfb83; BYTE $0x65 // cmpl $101, %ebx + LONG $0x0094850f; WORD $0x0000 // jne LBB27_40, $148(%rip) + +LBB27_32: + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x0149850f; WORD $0x0000 // jne LBB27_58, $329(%rip) + LONG $0x060c8d4c // leaq (%rsi,%rax), %r9 + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB27_39: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc7 // cmpq %rax, %r15 + LONG $0x0060840f; WORD $0x0000 // je LBB27_41, $96(%rip) + +LBB27_29: + LONG $0x011cbe0f // movsbl (%rcx,%rax), %ebx + WORD $0x538d; BYTE $0xd0 // leal $-48(%rbx), %edx + WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx + LONG $0xffe4820f; WORD $0xffff // jb LBB27_39, $-28(%rip) + WORD $0x538d; BYTE $0xd5 // leal $-43(%rbx), %edx + WORD $0xfa83; BYTE $0x1a // cmpl $26, %edx + LONG $0xffbc870f; WORD $0xffff // ja LBB27_31, $-68(%rip) + LONG $0x96146349 // movslq (%r14,%rdx,4), %rdx + WORD $0x014c; BYTE $0xf2 // addq %r14, %rdx + JMP DX + +LBB27_37: + LONG $0xfffa8349 // cmpq $-1, %r10 + LONG $0x0105850f; WORD $0x0000 // jne LBB27_58, $261(%rip) + LONG $0x06148d4c // leaq (%rsi,%rax), %r10 + LONG $0xffffbce9; BYTE $0xff // jmp LBB27_39, $-68(%rip) + +LBB27_35: + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x00f2850f; WORD $0x0000 // jne LBB27_58, $242(%rip) + LONG $0x06048d4c // leaq (%rsi,%rax), %r8 + LONG $0xffffa9e9; BYTE $0xff // jmp LBB27_39, $-87(%rip) + +LBB27_1: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0x00008fe9; BYTE $0x00 // jmp LBB27_55, $143(%rip) + +LBB27_57: + WORD $0x8941; BYTE $0xcb // movl %ecx, %r11d + WORD $0x0149; BYTE $0xfb // addq %rdi, %r11 + WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + +LBB27_41: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x001b850f; WORD $0x0000 // jne LBB27_42, $27(%rip) + LONG $0x000071e9; BYTE $0x00 // jmp LBB27_55, $113(%rip) + +LBB27_40: + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x005b840f; WORD $0x0000 // je LBB27_55, $91(%rip) + +LBB27_42: + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0052840f; WORD $0x0000 // je LBB27_55, $82(%rip) + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0049840f; WORD $0x0000 // je LBB27_55, $73(%rip) + WORD $0x2949; BYTE $0xfb // subq %rdi, %r11 + LONG $0xff438d49 // leaq $-1(%r11), %rax + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0033840f; WORD $0x0000 // je LBB27_47, $51(%rip) + WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 + LONG $0x002a840f; WORD $0x0000 // je LBB27_47, $42(%rip) + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x0021840f; WORD $0x0000 // je LBB27_47, $33(%rip) + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x00258e0f; WORD $0x0000 // jle LBB27_51, $37(%rip) + LONG $0xff428d49 // leaq $-1(%r10), %rax + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x0018840f; WORD $0x0000 // je LBB27_51, $24(%rip) + WORD $0xf749; BYTE $0xd2 // notq %r10 + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x000006e9; BYTE $0x00 // jmp LBB27_55, $6(%rip) + +LBB27_47: + WORD $0xf749; BYTE $0xdb // negq %r11 + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + +LBB27_55: + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB27_51: + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x094c; BYTE $0xc8 // orq %r9, %rax + WORD $0x990f; BYTE $0xc0 // setns %al + LONG $0x0014880f; WORD $0x0000 // js LBB27_54, $20(%rip) + WORD $0x394d; BYTE $0xc8 // cmpq %r9, %r8 + LONG $0x000b8c0f; WORD $0x0000 // jl LBB27_54, $11(%rip) + WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0xffffd6e9; BYTE $0xff // jmp LBB27_55, $-42(%rip) + +LBB27_54: + LONG $0xff498d49 // leaq $-1(%r9), %rcx + WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 + WORD $0xf749; BYTE $0xd1 // notq %r9 + LONG $0xcb450f4d // cmovneq %r11, %r9 + WORD $0xc084 // testb %al, %al + LONG $0xcb440f4d // cmoveq %r11, %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0xffffbae9; BYTE $0xff // jmp LBB27_55, $-70(%rip) + +LBB27_12: + WORD $0xbc0f; BYTE $0xca // bsfl %edx, %ecx + LONG $0x000010e9; BYTE $0x00 // jmp LBB27_13, $16(%rip) + +LBB27_58: + WORD $0x2948; BYTE $0xcf // subq %rcx, %rdi + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + LONG $0xffffa4e9; BYTE $0xff // jmp LBB27_55, $-92(%rip) + +LBB27_56: + WORD $0xd989 // movl %ebx, %ecx + +LBB27_13: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x2948; BYTE $0xc8 // subq %rcx, %rax + LONG $0xffff97e9; BYTE $0xff // jmp LBB27_55, $-105(%rip) + +LBB27_7: + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 + LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 + LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 + LONG $0xfffe51e9; BYTE $0xff // jmp LBB27_28, $-431(%rip) + BYTE $0x90 // .p2align 2, 0x90 + + // .set L27_0_set_37, LBB27_37-LJTI27_0 + // .set L27_0_set_40, LBB27_40-LJTI27_0 + // .set L27_0_set_35, LBB27_35-LJTI27_0 + // .set L27_0_set_32, LBB27_32-LJTI27_0 +LJTI27_0: + LONG $0xfffffeb5 // .long L27_0_set_37 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xfffffeb5 // .long L27_0_set_37 + LONG $0xfffffec8 // .long L27_0_set_35 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xfffffe71 // .long L27_0_set_32 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +_skip_positive: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b4c; BYTE $0x3e // movq (%rsi), %r15 + LONG $0xff5f8d49 // leaq $-1(%r15), %rbx + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0x08778b48 // movq $8(%rdi), %rsi + WORD $0x2948; BYTE $0xde // subq %rbx, %rsi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xfffbf7e8; BYTE $0xff // callq _do_skip_number, $-1033(%rip) + LONG $0xff508d48 // leaq $-1(%rax), %rdx + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0xfec6c748; WORD $0xffff; BYTE $0xff // movq $-2, %rsi + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xf2490f48 // cmovnsq %rdx, %rsi + LONG $0xcb490f48 // cmovnsq %rbx, %rcx + WORD $0x014c; BYTE $0xfe // addq %r15, %rsi + WORD $0x8949; BYTE $0x36 // movq %rsi, (%r14) + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_skip_number: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b4c; BYTE $0x27 // movq (%rdi), %r12 + LONG $0x08778b48 // movq $8(%rdi), %rsi + WORD $0x8b4d; BYTE $0x3e // movq (%r14), %r15 + WORD $0xc031 // xorl %eax, %eax + LONG $0x3c3c8043; BYTE $0x2d // cmpb $45, (%r12,%r15) + LONG $0x3c1c8d4b // leaq (%r12,%r15), %rbx + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + LONG $0x003c840f; WORD $0x0000 // je LBB29_6, $60(%rip) + WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 + LONG $0x000d830f; WORD $0x0000 // jae LBB29_3, $13(%rip) + WORD $0xb60f; BYTE $0x03 // movzbl (%rbx), %eax + WORD $0xc604 // addb $-58, %al + WORD $0xf63c // cmpb $-10, %al + LONG $0x0038820f; WORD $0x0000 // jb LBB29_8, $56(%rip) + +LBB29_3: + WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi + LONG $0xfffb70e8; BYTE $0xff // callq _do_skip_number, $-1168(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0021880f; WORD $0x0000 // js LBB29_7, $33(%rip) + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + +LBB29_5: + WORD $0x294c; BYTE $0xe3 // subq %r12, %rbx + WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB29_6: + LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq $-1, %r15 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB29_5, $-30(%rip) + +LBB29_7: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + +LBB29_8: + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + LONG $0xffffd0e9; BYTE $0xff // jmp LBB29_5, $-48(%rip) + LONG $0x00000000 // .p2align 4, 0x00 + +LCPI30_0: + LONG $0x00000001 // .long 1 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + + // .p2align 4, 0x90 +_skip_one: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI30_0(%rip) */ + LONG $0x0011f8c5 // vmovups %xmm0, (%rax) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0xfff25ee9; BYTE $0xff // jmp _fsm_exec, $-3490(%rip) + QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI31_0: + LONG $0x00000001 // .long 1 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + + // .p2align 4, 0x90 +_validate_one: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI31_0(%rip) */ + LONG $0x0011f8c5 // vmovups %xmm0, (%rax) + LONG $0x000020b9; BYTE $0x00 // movl $32, %ecx + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0xfff219e9; BYTE $0xff // jmp _fsm_exec, $-3559(%rip) + QUAD $0x0000000000000000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI32_0: + QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,' + +LCPI32_1: + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + +LCPI32_2: + QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]' + +LCPI32_3: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI32_4: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI32_5: + QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{' + +LCPI32_6: + QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}' + +LCPI32_7: + QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[[' + + // .p2align 4, 0x90 +_skip_one_fast: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0xe0e48348 // andq $-32, %rsp + LONG $0x80ec8148; WORD $0x0000; BYTE $0x00 // subq $128, %rsp + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + WORD $0x8b48; BYTE $0x3f // movq (%rdi), %rdi + LONG $0x08778b49 // movq $8(%r15), %rsi + WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx + LONG $0xffe043e8; BYTE $0xff // callq _advance_ns, $-8125(%rip) + WORD $0x8b49; BYTE $0x16 // movq (%r14), %rdx + LONG $0xff528d4c // leaq $-1(%rdx), %r10 + WORD $0xbe0f; BYTE $0xc8 // movsbl %al, %ecx + WORD $0xf983; BYTE $0x7b // cmpl $123, %ecx + LONG $0x0111870f; WORD $0x0000 // ja LBB32_18, $273(%rip) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xd6358d48; WORD $0x0009; BYTE $0x00 // leaq $2518(%rip), %rsi /* LJTI32_0(%rip) */ + LONG $0x8e0c6348 // movslq (%rsi,%rcx,4), %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + JMP CX + +LBB32_2: + WORD $0x8b49; BYTE $0x07 // movq (%r15), %rax + LONG $0x08778b49 // movq $8(%r15), %rsi + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx + LONG $0x10f98348 // cmpq $16, %rcx + LONG $0x0909820f; WORD $0x0000 // jb LBB32_82, $2313(%rip) + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0xf748; BYTE $0xd9 // negq %rcx + QUAD $0xffffff04056ff9c5 // vmovdqa $-252(%rip), %xmm0 /* LCPI32_0(%rip) */ + QUAD $0xffffff0c0d6ff9c5 // vmovdqa $-244(%rip), %xmm1 /* LCPI32_1(%rip) */ + QUAD $0xffffff14156ff9c5 // vmovdqa $-236(%rip), %xmm2 /* LCPI32_2(%rip) */ + LONG $0x90909090 // .p2align 4, 0x90 + +LBB32_4: + LONG $0x1c6ffac5; BYTE $0x10 // vmovdqu (%rax,%rdx), %xmm3 + LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 + LONG $0xd9dbe1c5 // vpand %xmm1, %xmm3, %xmm3 + LONG $0xda74e1c5 // vpcmpeqb %xmm2, %xmm3, %xmm3 + LONG $0xdcebe1c5 // vpor %xmm4, %xmm3, %xmm3 + LONG $0xfbd7f9c5 // vpmovmskb %xmm3, %edi + WORD $0xff85 // testl %edi, %edi + LONG $0x006b850f; WORD $0x0000 // jne LBB32_14, $107(%rip) + LONG $0x10c28348 // addq $16, %rdx + LONG $0x0e3c8d48 // leaq (%rsi,%rcx), %rdi + LONG $0xf0c78348 // addq $-16, %rdi + LONG $0xf0c18348 // addq $-16, %rcx + LONG $0x0fff8348 // cmpq $15, %rdi + LONG $0xffc5870f; WORD $0xffff // ja LBB32_4, $-59(%rip) + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x2948; BYTE $0xca // subq %rcx, %rdx + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0034840f; WORD $0x0000 // je LBB32_13, $52(%rip) + +LBB32_7: + LONG $0x0a3c8d48 // leaq (%rdx,%rcx), %rdi + WORD $0xf631 // xorl %esi, %esi + +LBB32_8: + LONG $0x321cb60f // movzbl (%rdx,%rsi), %ebx + WORD $0xfb83; BYTE $0x2c // cmpl $44, %ebx + LONG $0x0859840f; WORD $0x0000 // je LBB32_80, $2137(%rip) + WORD $0xfb83; BYTE $0x7d // cmpl $125, %ebx + LONG $0x0850840f; WORD $0x0000 // je LBB32_80, $2128(%rip) + WORD $0xfb83; BYTE $0x5d // cmpl $93, %ebx + LONG $0x0847840f; WORD $0x0000 // je LBB32_80, $2119(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx + LONG $0xffd5850f; WORD $0xffff // jne LBB32_8, $-43(%rip) + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + +LBB32_13: + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + LONG $0x000836e9; BYTE $0x00 // jmp LBB32_81, $2102(%rip) + +LBB32_14: + LONG $0xc7bc0f66 // bsfw %di, %ax + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0x2948; BYTE $0xc8 // subq %rcx, %rax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + +LBB32_15: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + +LBB32_16: + LONG $0xd8658d48 // leaq $-40(%rbp), %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB32_17: + LONG $0x03c28348 // addq $3, %rdx + LONG $0x08573b49 // cmpq $8(%r15), %rdx + LONG $0xffe0830f; WORD $0xffff // jae LBB32_16, $-32(%rip) + LONG $0x000801e9; BYTE $0x00 // jmp LBB32_81, $2049(%rip) + +LBB32_18: + WORD $0x894d; BYTE $0x16 // movq %r10, (%r14) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xffffcce9; BYTE $0xff // jmp LBB32_16, $-52(%rip) + +LBB32_19: + WORD $0x894d; BYTE $0xd0 // movq %r10, %r8 + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x084f8b4d // movq $8(%r15), %r9 + LONG $0x244c8948; BYTE $0x08 // movq %rcx, $8(%rsp) + LONG $0x11148d4c // leaq (%rcx,%rdx), %r10 + WORD $0x2949; BYTE $0xd1 // subq %rdx, %r9 + LONG $0x20f98349 // cmpq $32, %r9 + LONG $0x07e9820f; WORD $0x0000 // jb LBB32_27, $2025(%rip) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + QUAD $0xfffffe25056ff9c5 // vmovdqa $-475(%rip), %xmm0 /* LCPI32_3(%rip) */ + QUAD $0xfffffe2d0d6ff9c5 // vmovdqa $-467(%rip), %xmm1 /* LCPI32_4(%rip) */ + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + LONG $0x000028e9; BYTE $0x00 // jmp LBB32_21, $40(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +LBB32_23: + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x009d850f; WORD $0x0000 // jne LBB32_79, $157(%rip) + +LBB32_24: + LONG $0x20c58349 // addq $32, %r13 + LONG $0x390c8d4b // leaq (%r9,%r15), %rcx + LONG $0xe0c18348 // addq $-32, %rcx + LONG $0xe0c78349 // addq $-32, %r15 + LONG $0x1ff98348 // cmpq $31, %rcx + LONG $0x0794860f; WORD $0x0000 // jbe LBB32_25, $1940(%rip) + +LBB32_21: + LONG $0x6f7a81c4; WORD $0x2a14 // vmovdqu (%r10,%r13), %xmm2 + LONG $0x6f7a81c4; WORD $0x2a5c; BYTE $0x10 // vmovdqu $16(%r10,%r13), %xmm3 + LONG $0xe074e9c5 // vpcmpeqb %xmm0, %xmm2, %xmm4 + LONG $0xfcd7f9c5 // vpmovmskb %xmm4, %edi + LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 + LONG $0xccd7f9c5 // vpmovmskb %xmm4, %ecx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx + LONG $0xd174e9c5 // vpcmpeqb %xmm1, %xmm2, %xmm2 + LONG $0xf2d7f9c5 // vpmovmskb %xmm2, %esi + LONG $0xd174e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm2 + LONG $0xfad7f9c5 // vpmovmskb %xmm2, %edi + LONG $0x10e7c148 // shlq $16, %rdi + WORD $0x0948; BYTE $0xf7 // orq %rsi, %rdi + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x094c; BYTE $0xde // orq %r11, %rsi + LONG $0xff93840f; WORD $0xffff // je LBB32_23, $-109(%rip) + WORD $0x8944; BYTE $0xde // movl %r11d, %esi + WORD $0xd6f7 // notl %esi + WORD $0xfe21 // andl %edi, %esi + LONG $0x36248d44 // leal (%rsi,%rsi), %r12d + WORD $0x0945; BYTE $0xdc // orl %r11d, %r12d + WORD $0x8944; BYTE $0xe3 // movl %r12d, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xfb21 // andl %edi, %ebx + LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0xf301 // addl %esi, %ebx + LONG $0xc3920f41 // setb %r11b + WORD $0xdb01 // addl %ebx, %ebx + LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx + WORD $0x2144; BYTE $0xe3 // andl %r12d, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xd921 // andl %ebx, %ecx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0xff63840f; WORD $0xffff // je LBB32_24, $-157(%rip) + +LBB32_79: + WORD $0xbc0f; BYTE $0xc1 // bsfl %ecx, %eax + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0xfffecce9; BYTE $0xff // jmp LBB32_16, $-308(%rip) + +LBB32_28: + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx + WORD $0x0349; BYTE $0x17 // addq (%r15), %rdx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + QUAD $0xfffffd4b156f79c5 // vmovdqa $-693(%rip), %xmm10 /* LCPI32_4(%rip) */ + QUAD $0xfffffd330d6ff9c5 // vmovdqa $-717(%rip), %xmm1 /* LCPI32_3(%rip) */ + LONG $0x763141c4; BYTE $0xc9 // vpcmpeqd %xmm9, %xmm9, %xmm9 + QUAD $0xfffffd661d6ff9c5 // vmovdqa $-666(%rip), %xmm3 /* LCPI32_7(%rip) */ + QUAD $0xfffffd0e256ff9c5 // vmovdqa $-754(%rip), %xmm4 /* LCPI32_2(%rip) */ + LONG $0x573841c4; BYTE $0xc0 // vxorps %xmm8, %xmm8, %xmm8 + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xf631 // xorl %esi, %esi + LONG $0x2454894c; BYTE $0x18 // movq %r10, $24(%rsp) + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0x244c8948; BYTE $0x08 // movq %rcx, $8(%rsp) + LONG $0x011f8d0f; WORD $0x0000 // jge LBB32_29, $287(%rip) + +LBB32_38: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x06cc8e0f; WORD $0x0000 // jle LBB32_83, $1740(%rip) + LONG $0x44297cc5; WORD $0x4024 // vmovaps %ymm8, $64(%rsp) + LONG $0x44297cc5; WORD $0x2024 // vmovaps %ymm8, $32(%rsp) + WORD $0xd189 // movl %edx, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx + LONG $0x00f6820f; WORD $0x0000 // jb LBB32_29, $246(%rip) + LONG $0x247c8348; WORD $0x2008 // cmpq $32, $8(%rsp) + LONG $0x0021820f; WORD $0x0000 // jb LBB32_42, $33(%rip) + LONG $0x026ffec5 // vmovdqu (%rdx), %ymm0 + LONG $0x447ffdc5; WORD $0x2024 // vmovdqa %ymm0, $32(%rsp) + LONG $0x20c28348 // addq $32, %rdx + LONG $0x244c8b48; BYTE $0x08 // movq $8(%rsp), %rcx + LONG $0xe0798d48 // leaq $-32(%rcx), %rdi + LONG $0x245c8d48; BYTE $0x40 // leaq $64(%rsp), %rbx + LONG $0x00000ae9; BYTE $0x00 // jmp LBB32_43, $10(%rip) + +LBB32_42: + LONG $0x245c8d48; BYTE $0x20 // leaq $32(%rsp), %rbx + LONG $0x247c8b48; BYTE $0x08 // movq $8(%rsp), %rdi + +LBB32_43: + LONG $0x10ff8348 // cmpq $16, %rdi + LONG $0x0058820f; WORD $0x0000 // jb LBB32_44, $88(%rip) + LONG $0x026ffac5 // vmovdqu (%rdx), %xmm0 + LONG $0x037ffac5 // vmovdqu %xmm0, (%rbx) + LONG $0x10c28348 // addq $16, %rdx + LONG $0x10c38348 // addq $16, %rbx + LONG $0xf0c78348 // addq $-16, %rdi + LONG $0x08ff8348 // cmpq $8, %rdi + LONG $0x0044830f; WORD $0x0000 // jae LBB32_49, $68(%rip) + +LBB32_45: + LONG $0x04ff8348 // cmpq $4, %rdi + LONG $0x0056820f; WORD $0x0000 // jb LBB32_46, $86(%rip) + +LBB32_50: + WORD $0x0a8b // movl (%rdx), %ecx + WORD $0x0b89 // movl %ecx, (%rbx) + LONG $0x04c28348 // addq $4, %rdx + LONG $0x04c38348 // addq $4, %rbx + LONG $0xfcc78348 // addq $-4, %rdi + LONG $0x02ff8348 // cmpq $2, %rdi + LONG $0x0046830f; WORD $0x0000 // jae LBB32_51, $70(%rip) + +LBB32_47: + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0058850f; WORD $0x0000 // jne LBB32_52, $88(%rip) + LONG $0x00005de9; BYTE $0x00 // jmp LBB32_29, $93(%rip) + +LBB32_44: + LONG $0x08ff8348 // cmpq $8, %rdi + LONG $0xffbc820f; WORD $0xffff // jb LBB32_45, $-68(%rip) + +LBB32_49: + WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + LONG $0x08c28348 // addq $8, %rdx + LONG $0x08c38348 // addq $8, %rbx + LONG $0xf8c78348 // addq $-8, %rdi + LONG $0x04ff8348 // cmpq $4, %rdi + LONG $0xffaa830f; WORD $0xffff // jae LBB32_50, $-86(%rip) + +LBB32_46: + LONG $0x02ff8348 // cmpq $2, %rdi + LONG $0xffba820f; WORD $0xffff // jb LBB32_47, $-70(%rip) + +LBB32_51: + WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx + WORD $0x8966; BYTE $0x0b // movw %cx, (%rbx) + LONG $0x02c28348 // addq $2, %rdx + LONG $0x02c38348 // addq $2, %rbx + LONG $0xfec78348 // addq $-2, %rdi + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x000a840f; WORD $0x0000 // je LBB32_29, $10(%rip) + +LBB32_52: + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + WORD $0x0b88 // movb %cl, (%rbx) + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + +LBB32_29: + LONG $0x126ffac5 // vmovdqu (%rdx), %xmm2 + LONG $0x6a6ffac5; BYTE $0x10 // vmovdqu $16(%rdx), %xmm5 + LONG $0x7a6ffac5; BYTE $0x20 // vmovdqu $32(%rdx), %xmm7 + LONG $0x726ffac5; BYTE $0x30 // vmovdqu $48(%rdx), %xmm6 + LONG $0xc274a9c5 // vpcmpeqb %xmm2, %xmm10, %xmm0 + LONG $0xe8d779c5 // vpmovmskb %xmm0, %r13d + LONG $0xc574a9c5 // vpcmpeqb %xmm5, %xmm10, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0xc774a9c5 // vpcmpeqb %xmm7, %xmm10, %xmm0 + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0xc674a9c5 // vpcmpeqb %xmm6, %xmm10, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + LONG $0x10e7c148 // shlq $16, %rdi + WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi + WORD $0x0949; BYTE $0xfd // orq %rdi, %r13 + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + WORD $0x094c; BYTE $0xd9 // orq %r11, %rcx + LONG $0x0013850f; WORD $0x0000 // jne LBB32_31, $19(%rip) + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x244c8948; BYTE $0x10 // movq %rcx, $16(%rsp) + LONG $0x00004ae9; BYTE $0x00 // jmp LBB32_32, $74(%rip) + +LBB32_31: + WORD $0x894c; BYTE $0xd9 // movq %r11, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + LONG $0x09148d4c // leaq (%rcx,%rcx), %r10 + WORD $0x094d; BYTE $0xda // orq %r11, %r10 + WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx + WORD $0x2149; BYTE $0xdd // andq %rbx, %r13 + WORD $0x2149; BYTE $0xfd // andq %rdi, %r13 + WORD $0xff31 // xorl %edi, %edi + WORD $0x0149; BYTE $0xcd // addq %rcx, %r13 + LONG $0xc7920f40 // setb %dil + LONG $0x247c8948; BYTE $0x10 // movq %rdi, $16(%rsp) + WORD $0x014d; BYTE $0xed // addq %r13, %r13 + QUAD $0x555555555555b948; WORD $0x5555 // movabsq $6148914691236517205, %rcx + WORD $0x3149; BYTE $0xcd // xorq %rcx, %r13 + WORD $0x214d; BYTE $0xd5 // andq %r10, %r13 + WORD $0xf749; BYTE $0xd5 // notq %r13 + +LBB32_32: + LONG $0xc174c9c5 // vpcmpeqb %xmm1, %xmm6, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0xc174c1c5 // vpcmpeqb %xmm1, %xmm7, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi + LONG $0xc174d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx + LONG $0xc174e9c5 // vpcmpeqb %xmm1, %xmm2, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi + WORD $0x214c; BYTE $0xef // andq %r13, %rdi + LONG $0x6ef9e1c4; BYTE $0xc7 // vmovq %rdi, %xmm0 + LONG $0x4479c3c4; WORD $0x00c1 // vpclmulqdq $0, %xmm9, %xmm0, %xmm0 + LONG $0x7ef9c1c4; BYTE $0xc5 // vmovq %xmm0, %r13 + WORD $0x314d; BYTE $0xcd // xorq %r9, %r13 + LONG $0xc374e9c5 // vpcmpeqb %xmm3, %xmm2, %xmm0 + LONG $0xd0d779c5 // vpmovmskb %xmm0, %r10d + LONG $0xc374d1c5 // vpcmpeqb %xmm3, %xmm5, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0xc374c1c5 // vpcmpeqb %xmm3, %xmm7, %xmm0 + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0xc374c9c5 // vpcmpeqb %xmm3, %xmm6, %xmm0 + LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d + LONG $0x30e1c149 // shlq $48, %r9 + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x094c; BYTE $0xcb // orq %r9, %rbx + LONG $0x10e7c148 // shlq $16, %rdi + WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi + WORD $0x0949; BYTE $0xfa // orq %rdi, %r10 + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x214d; BYTE $0xca // andq %r9, %r10 + LONG $0xc474e9c5 // vpcmpeqb %xmm4, %xmm2, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0xc474d1c5 // vpcmpeqb %xmm4, %xmm5, %xmm0 + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0xc474c1c5 // vpcmpeqb %xmm4, %xmm7, %xmm0 + LONG $0xd8d779c5 // vpmovmskb %xmm0, %r11d + LONG $0xc474c9c5 // vpcmpeqb %xmm4, %xmm6, %xmm0 + LONG $0xe0d779c5 // vpmovmskb %xmm0, %r12d + LONG $0x30e4c149 // shlq $48, %r12 + LONG $0x20e3c149 // shlq $32, %r11 + WORD $0x094d; BYTE $0xe3 // orq %r12, %r11 + LONG $0x10e3c148 // shlq $16, %rbx + WORD $0x094c; BYTE $0xdb // orq %r11, %rbx + WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi + WORD $0x214c; BYTE $0xcf // andq %r9, %rdi + LONG $0x0032840f; WORD $0x0000 // je LBB32_36, $50(%rip) + LONG $0x245c8b4c; BYTE $0x10 // movq $16(%rsp), %r11 + BYTE $0x90 // .p2align 4, 0x90 + +LBB32_34: + LONG $0xff4f8d48 // leaq $-1(%rdi), %rcx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + WORD $0x214c; BYTE $0xd3 // andq %r10, %rbx + LONG $0xb80f48f3; BYTE $0xdb // popcntq %rbx, %rbx + WORD $0x014c; BYTE $0xc3 // addq %r8, %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x03a5860f; WORD $0x0000 // jbe LBB32_78, $933(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + LONG $0xffd9850f; WORD $0xffff // jne LBB32_34, $-39(%rip) + LONG $0x000005e9; BYTE $0x00 // jmp LBB32_37, $5(%rip) + +LBB32_36: + LONG $0x245c8b4c; BYTE $0x10 // movq $16(%rsp), %r11 + +LBB32_37: + LONG $0x3ffdc149 // sarq $63, %r13 + LONG $0xb80f49f3; BYTE $0xca // popcntq %r10, %rcx + WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 + LONG $0x40c28348 // addq $64, %rdx + LONG $0x244c8b48; BYTE $0x08 // movq $8(%rsp), %rcx + LONG $0xc0c18348 // addq $-64, %rcx + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0x244c8948; BYTE $0x08 // movq %rcx, $8(%rsp) + LONG $0xfe268d0f; WORD $0xffff // jge LBB32_29, $-474(%rip) + LONG $0xfffd02e9; BYTE $0xff // jmp LBB32_38, $-766(%rip) + +LBB32_53: + LONG $0x04c28348 // addq $4, %rdx + LONG $0x08573b49 // cmpq $8(%r15), %rdx + LONG $0xfb6d830f; WORD $0xffff // jae LBB32_16, $-1171(%rip) + LONG $0x00038ee9; BYTE $0x00 // jmp LBB32_81, $910(%rip) + +LBB32_54: + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx + WORD $0x0349; BYTE $0x17 // addq (%r15), %rdx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + QUAD $0xfffff9e7156f79c5 // vmovdqa $-1561(%rip), %xmm10 /* LCPI32_4(%rip) */ + QUAD $0xfffff9cf0d6ff9c5 // vmovdqa $-1585(%rip), %xmm1 /* LCPI32_3(%rip) */ + LONG $0x763141c4; BYTE $0xc9 // vpcmpeqd %xmm9, %xmm9, %xmm9 + QUAD $0xfffff9e21d6ff9c5 // vmovdqa $-1566(%rip), %xmm3 /* LCPI32_5(%rip) */ + QUAD $0xfffff9ea256ff9c5 // vmovdqa $-1558(%rip), %xmm4 /* LCPI32_6(%rip) */ + LONG $0x573841c4; BYTE $0xc0 // vxorps %xmm8, %xmm8, %xmm8 + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xf631 // xorl %esi, %esi + LONG $0x2454894c; BYTE $0x18 // movq %r10, $24(%rsp) + LONG $0x000021e9; BYTE $0x00 // jmp LBB32_56, $33(%rip) + +LBB32_55: + LONG $0x3ffdc149 // sarq $63, %r13 + LONG $0xb80f49f3; BYTE $0xca // popcntq %r10, %rcx + WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 + LONG $0x40c28348 // addq $64, %rdx + LONG $0x244c8b48; BYTE $0x08 // movq $8(%rsp), %rcx + LONG $0xc0c18348 // addq $-64, %rcx + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + LONG $0x245c8b4c; BYTE $0x10 // movq $16(%rsp), %r11 + +LBB32_56: + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0x244c8948; BYTE $0x08 // movq %rcx, $8(%rsp) + LONG $0x01af8c0f; WORD $0x0000 // jl LBB32_63, $431(%rip) + +LBB32_57: + LONG $0x126ffac5 // vmovdqu (%rdx), %xmm2 + LONG $0x6a6ffac5; BYTE $0x10 // vmovdqu $16(%rdx), %xmm5 + LONG $0x7a6ffac5; BYTE $0x20 // vmovdqu $32(%rdx), %xmm7 + LONG $0x726ffac5; BYTE $0x30 // vmovdqu $48(%rdx), %xmm6 + LONG $0xc274a9c5 // vpcmpeqb %xmm2, %xmm10, %xmm0 + LONG $0xe0d779c5 // vpmovmskb %xmm0, %r12d + LONG $0xc574a9c5 // vpcmpeqb %xmm5, %xmm10, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0xc774a9c5 // vpcmpeqb %xmm7, %xmm10, %xmm0 + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0xc674a9c5 // vpcmpeqb %xmm6, %xmm10, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + LONG $0x10e7c148 // shlq $16, %rdi + WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi + WORD $0x0949; BYTE $0xfc // orq %rdi, %r12 + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + WORD $0x094c; BYTE $0xd9 // orq %r11, %rcx + LONG $0x0013850f; WORD $0x0000 // jne LBB32_59, $19(%rip) + LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x244c8948; BYTE $0x10 // movq %rcx, $16(%rsp) + LONG $0x00004ae9; BYTE $0x00 // jmp LBB32_60, $74(%rip) + +LBB32_59: + WORD $0x894c; BYTE $0xd9 // movq %r11, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x214c; BYTE $0xe1 // andq %r12, %rcx + LONG $0x09148d4c // leaq (%rcx,%rcx), %r10 + WORD $0x094d; BYTE $0xda // orq %r11, %r10 + WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx + WORD $0x2149; BYTE $0xdc // andq %rbx, %r12 + WORD $0x2149; BYTE $0xfc // andq %rdi, %r12 + WORD $0xff31 // xorl %edi, %edi + WORD $0x0149; BYTE $0xcc // addq %rcx, %r12 + LONG $0xc7920f40 // setb %dil + LONG $0x247c8948; BYTE $0x10 // movq %rdi, $16(%rsp) + WORD $0x014d; BYTE $0xe4 // addq %r12, %r12 + QUAD $0x555555555555b948; WORD $0x5555 // movabsq $6148914691236517205, %rcx + WORD $0x3149; BYTE $0xcc // xorq %rcx, %r12 + WORD $0x214d; BYTE $0xd4 // andq %r10, %r12 + WORD $0xf749; BYTE $0xd4 // notq %r12 + +LBB32_60: + LONG $0xc174c9c5 // vpcmpeqb %xmm1, %xmm6, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0xc174c1c5 // vpcmpeqb %xmm1, %xmm7, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi + LONG $0xc174d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx + LONG $0xc174e9c5 // vpcmpeqb %xmm1, %xmm2, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi + WORD $0x214c; BYTE $0xe7 // andq %r12, %rdi + LONG $0x6ef9e1c4; BYTE $0xc7 // vmovq %rdi, %xmm0 + LONG $0x4479c3c4; WORD $0x00c1 // vpclmulqdq $0, %xmm9, %xmm0, %xmm0 + LONG $0x7ef9c1c4; BYTE $0xc5 // vmovq %xmm0, %r13 + WORD $0x314d; BYTE $0xcd // xorq %r9, %r13 + LONG $0xc374e9c5 // vpcmpeqb %xmm3, %xmm2, %xmm0 + LONG $0xd0d779c5 // vpmovmskb %xmm0, %r10d + LONG $0xc374d1c5 // vpcmpeqb %xmm3, %xmm5, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0xc374c1c5 // vpcmpeqb %xmm3, %xmm7, %xmm0 + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0xc374c9c5 // vpcmpeqb %xmm3, %xmm6, %xmm0 + LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d + LONG $0x30e1c149 // shlq $48, %r9 + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x094c; BYTE $0xcb // orq %r9, %rbx + LONG $0x10e7c148 // shlq $16, %rdi + WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi + WORD $0x0949; BYTE $0xfa // orq %rdi, %r10 + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x214d; BYTE $0xca // andq %r9, %r10 + LONG $0xc474e9c5 // vpcmpeqb %xmm4, %xmm2, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0xc474d1c5 // vpcmpeqb %xmm4, %xmm5, %xmm0 + LONG $0xe0d779c5 // vpmovmskb %xmm0, %r12d + LONG $0xc474c1c5 // vpcmpeqb %xmm4, %xmm7, %xmm0 + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0xc474c9c5 // vpcmpeqb %xmm4, %xmm6, %xmm0 + LONG $0xd8d779c5 // vpmovmskb %xmm0, %r11d + LONG $0x30e3c149 // shlq $48, %r11 + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x094c; BYTE $0xdb // orq %r11, %rbx + LONG $0x10e4c149 // shlq $16, %r12 + WORD $0x0949; BYTE $0xdc // orq %rbx, %r12 + WORD $0x094c; BYTE $0xe7 // orq %r12, %rdi + WORD $0x214c; BYTE $0xcf // andq %r9, %rdi + LONG $0xfe58840f; WORD $0xffff // je LBB32_55, $-424(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB32_61: + LONG $0xff4f8d48 // leaq $-1(%rdi), %rcx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + WORD $0x214c; BYTE $0xd3 // andq %r10, %rbx + LONG $0xb80f48f3; BYTE $0xdb // popcntq %rbx, %rbx + WORD $0x014c; BYTE $0xc3 // addq %r8, %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0135860f; WORD $0x0000 // jbe LBB32_78, $309(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + LONG $0xffd9850f; WORD $0xffff // jne LBB32_61, $-39(%rip) + LONG $0xfffe21e9; BYTE $0xff // jmp LBB32_55, $-479(%rip) + +LBB32_63: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x01938e0f; WORD $0x0000 // jle LBB32_83, $403(%rip) + LONG $0x44297cc5; WORD $0x4024 // vmovaps %ymm8, $64(%rsp) + LONG $0x44297cc5; WORD $0x2024 // vmovaps %ymm8, $32(%rsp) + WORD $0xd189 // movl %edx, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx + LONG $0xfe28820f; WORD $0xffff // jb LBB32_57, $-472(%rip) + LONG $0x247c8348; WORD $0x2008 // cmpq $32, $8(%rsp) + LONG $0x0021820f; WORD $0x0000 // jb LBB32_67, $33(%rip) + LONG $0x0210fcc5 // vmovups (%rdx), %ymm0 + LONG $0x4429fcc5; WORD $0x2024 // vmovaps %ymm0, $32(%rsp) + LONG $0x20c28348 // addq $32, %rdx + LONG $0x244c8b48; BYTE $0x08 // movq $8(%rsp), %rcx + LONG $0xe0798d48 // leaq $-32(%rcx), %rdi + LONG $0x245c8d48; BYTE $0x40 // leaq $64(%rsp), %rbx + LONG $0x00000ae9; BYTE $0x00 // jmp LBB32_68, $10(%rip) + +LBB32_67: + LONG $0x245c8d48; BYTE $0x20 // leaq $32(%rsp), %rbx + LONG $0x247c8b48; BYTE $0x08 // movq $8(%rsp), %rdi + +LBB32_68: + LONG $0x10ff8348 // cmpq $16, %rdi + LONG $0x0058820f; WORD $0x0000 // jb LBB32_69, $88(%rip) + LONG $0x0210f8c5 // vmovups (%rdx), %xmm0 + LONG $0x0311f8c5 // vmovups %xmm0, (%rbx) + LONG $0x10c28348 // addq $16, %rdx + LONG $0x10c38348 // addq $16, %rbx + LONG $0xf0c78348 // addq $-16, %rdi + LONG $0x08ff8348 // cmpq $8, %rdi + LONG $0x0044830f; WORD $0x0000 // jae LBB32_74, $68(%rip) + +LBB32_70: + LONG $0x04ff8348 // cmpq $4, %rdi + LONG $0x0056820f; WORD $0x0000 // jb LBB32_71, $86(%rip) + +LBB32_75: + WORD $0x0a8b // movl (%rdx), %ecx + WORD $0x0b89 // movl %ecx, (%rbx) + LONG $0x04c28348 // addq $4, %rdx + LONG $0x04c38348 // addq $4, %rbx + LONG $0xfcc78348 // addq $-4, %rdi + LONG $0x02ff8348 // cmpq $2, %rdi + LONG $0x0046830f; WORD $0x0000 // jae LBB32_76, $70(%rip) + +LBB32_72: + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0058850f; WORD $0x0000 // jne LBB32_77, $88(%rip) + LONG $0xfffd8fe9; BYTE $0xff // jmp LBB32_57, $-625(%rip) + +LBB32_69: + LONG $0x08ff8348 // cmpq $8, %rdi + LONG $0xffbc820f; WORD $0xffff // jb LBB32_70, $-68(%rip) + +LBB32_74: + WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + LONG $0x08c28348 // addq $8, %rdx + LONG $0x08c38348 // addq $8, %rbx + LONG $0xf8c78348 // addq $-8, %rdi + LONG $0x04ff8348 // cmpq $4, %rdi + LONG $0xffaa830f; WORD $0xffff // jae LBB32_75, $-86(%rip) + +LBB32_71: + LONG $0x02ff8348 // cmpq $2, %rdi + LONG $0xffba820f; WORD $0xffff // jb LBB32_72, $-70(%rip) + +LBB32_76: + WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx + WORD $0x8966; BYTE $0x0b // movw %cx, (%rbx) + LONG $0x02c28348 // addq $2, %rdx + LONG $0x02c38348 // addq $2, %rbx + LONG $0xfec78348 // addq $-2, %rdi + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xfd3c840f; WORD $0xffff // je LBB32_57, $-708(%rip) + +LBB32_77: + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + WORD $0x0b88 // movb %cl, (%rbx) + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + LONG $0xfffd2de9; BYTE $0xff // jmp LBB32_57, $-723(%rip) + +LBB32_78: + LONG $0x08478b49 // movq $8(%r15), %rax + LONG $0xcfbc0f48 // bsfq %rdi, %rcx + LONG $0x244c2b48; BYTE $0x08 // subq $8(%rsp), %rcx + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0xc8420f48 // cmovbq %rax, %rcx + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0x244c8b48; BYTE $0x18 // movq $24(%rsp), %rcx + LONG $0xc8470f48 // cmovaq %rax, %rcx + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xfff7e0e9; BYTE $0xff // jmp LBB32_16, $-2080(%rip) + +LBB32_80: + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + WORD $0x0148; BYTE $0xf2 // addq %rsi, %rdx + +LBB32_81: + WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) + LONG $0xfff7cfe9; BYTE $0xff // jmp LBB32_15, $-2097(%rip) + +LBB32_25: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0031850f; WORD $0x0000 // jne LBB32_84, $49(%rip) + WORD $0x014d; BYTE $0xea // addq %r13, %r10 + WORD $0x014d; BYTE $0xf9 // addq %r15, %r9 + +LBB32_27: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0064850f; WORD $0x0000 // jne LBB32_88, $100(%rip) + LONG $0xfff7b5e9; BYTE $0xff // jmp LBB32_16, $-2123(%rip) + +LBB32_82: + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0xf75d850f; WORD $0xffff // jne LBB32_7, $-2211(%rip) + LONG $0xfff78ce9; BYTE $0xff // jmp LBB32_13, $-2164(%rip) + +LBB32_83: + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0xfff798e9; BYTE $0xff // jmp LBB32_16, $-2152(%rip) + +LBB32_84: + WORD $0x394d; BYTE $0xe9 // cmpq %r13, %r9 + LONG $0xf78f840f; WORD $0xffff // je LBB32_16, $-2161(%rip) + WORD $0x014d; BYTE $0xea // addq %r13, %r10 + WORD $0xff49; BYTE $0xc2 // incq %r10 + WORD $0xf749; BYTE $0xd5 // notq %r13 + WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0024850f; WORD $0x0000 // jne LBB32_88, $36(%rip) + LONG $0xfff775e9; BYTE $0xff // jmp LBB32_16, $-2187(%rip) + +LBB32_86: + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + LONG $0xf756840f; WORD $0xffff // je LBB32_16, $-2218(%rip) + +LBB32_88: + LONG $0x02b60f41 // movzbl (%r10), %eax + WORD $0xf883; BYTE $0x5c // cmpl $92, %eax + LONG $0xffd4840f; WORD $0xffff // je LBB32_86, $-44(%rip) + WORD $0xf883; BYTE $0x22 // cmpl $34, %eax + LONG $0x0024840f; WORD $0x0000 // je LBB32_91, $36(%rip) + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + LONG $0xffcb850f; WORD $0xffff // jne LBB32_88, $-53(%rip) + LONG $0xfff71ce9; BYTE $0xff // jmp LBB32_16, $-2276(%rip) + +LBB32_91: + LONG $0x24542b4c; BYTE $0x08 // subq $8(%rsp), %r10 + WORD $0xff49; BYTE $0xc2 // incq %r10 + WORD $0x894d; BYTE $0x16 // movq %r10, (%r14) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0xfff709e9; BYTE $0xff // jmp LBB32_16, $-2295(%rip) + BYTE $0x90 // .p2align 2, 0x90 + + // .set L32_0_set_16, LBB32_16-LJTI32_0 + // .set L32_0_set_18, LBB32_18-LJTI32_0 + // .set L32_0_set_19, LBB32_19-LJTI32_0 + // .set L32_0_set_2, LBB32_2-LJTI32_0 + // .set L32_0_set_28, LBB32_28-LJTI32_0 + // .set L32_0_set_53, LBB32_53-LJTI32_0 + // .set L32_0_set_17, LBB32_17-LJTI32_0 + // .set L32_0_set_54, LBB32_54-LJTI32_0 +LJTI32_0: + LONG $0xfffff708 // .long L32_0_set_16 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff73c // .long L32_0_set_19 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff633 // .long L32_0_set_2 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff83c // .long L32_0_set_28 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffffb8d // .long L32_0_set_53 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff71a // .long L32_0_set_17 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff71a // .long L32_0_set_17 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffff72d // .long L32_0_set_18 + LONG $0xfffffba0 // .long L32_0_set_54 + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +_get_by_path: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x38ec8348 // subq $56, %rsp + WORD $0x8949; BYTE $0xf4 // movq %rsi, %r12 + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + LONG $0x08428b48 // movq $8(%rdx), %rax + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x038d840f; WORD $0x0000 // je LBB33_53, $909(%rip) + WORD $0x8b4c; BYTE $0x3a // movq (%rdx), %r15 + LONG $0x04e0c148 // shlq $4, %rax + WORD $0x014c; BYTE $0xf8 // addq %r15, %rax + LONG $0xa0458948 // movq %rax, $-96(%rbp) + +LBB33_2: + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffd40fe8; BYTE $0xff // callq _advance_ns, $-11249(%rip) + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x1749b60f // movzbl $23(%rcx), %ecx + WORD $0xe180; BYTE $0x1f // andb $31, %cl + WORD $0xf980; BYTE $0x18 // cmpb $24, %cl + LONG $0x02ec850f; WORD $0x0000 // jne LBB33_47, $748(%rip) + WORD $0x7b3c // cmpb $123, %al + LONG $0xc865894c // movq %r12, $-56(%rbp) + LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0x035d850f; WORD $0x0000 // jne LBB33_54, $861(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB33_4: + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffd3d1e8; BYTE $0xff // callq _advance_ns, $-11311(%rip) + WORD $0x223c // cmpb $34, %al + LONG $0x033a850f; WORD $0x0000 // jne LBB33_54, $826(%rip) + LONG $0x08478b49 // movq $8(%r15), %rax + WORD $0x8b4c; BYTE $0x28 // movq (%rax), %r13 + LONG $0x08788b4c // movq $8(%rax), %r15 + QUAD $0xffffffffb045c748 // movq $-1, $-80(%rbp) + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0x24248b4d // movq (%r12), %r12 + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0xb0558d48 // leaq $-80(%rbp), %rdx + LONG $0x001c40e8; BYTE $0x00 // callq _advance_string_default, $7232(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0322880f; WORD $0x0000 // js LBB33_56, $802(%rip) + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0xb04d8b48 // movq $-80(%rbp), %rcx + LONG $0xfff98348 // cmpq $-1, %rcx + LONG $0x0009840f; WORD $0x0000 // je LBB33_8, $9(%rip) + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x01578e0f; WORD $0x0000 // jle LBB33_27, $343(%rip) + +LBB33_8: + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax + LONG $0x003e850f; WORD $0x0000 // jne LBB33_12, $62(%rip) + WORD $0x034d; BYTE $0x26 // addq (%r14), %r12 + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + WORD $0x9090 // .p2align 4, 0x90 + +LBB33_10: + LONG $0x10ff8349 // cmpq $16, %r15 + LONG $0x0086820f; WORD $0x0000 // jb LBB33_17, $134(%rip) + LONG $0x006ffac5 // vmovdqu (%rax), %xmm0 + LONG $0xf879c1c4; WORD $0x0045 // vpsubb (%r13), %xmm0, %xmm0 + LONG $0x10c08348 // addq $16, %rax + LONG $0x10c58349 // addq $16, %r13 + LONG $0xf0c78349 // addq $-16, %r15 + LONG $0x10c18348 // addq $16, %rcx + LONG $0x10c48349 // addq $16, %r12 + LONG $0x1779e2c4; BYTE $0xc0 // vptest %xmm0, %xmm0 + LONG $0xffcd840f; WORD $0xffff // je LBB33_10, $-51(%rip) + +LBB33_12: + WORD $0xdb31 // xorl %ebx, %ebx + +LBB33_13: + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + +LBB33_14: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffd314e8; BYTE $0xff // callq _advance_ns, $-11500(%rip) + WORD $0x3a3c // cmpb $58, %al + LONG $0x027d850f; WORD $0x0000 // jne LBB33_54, $637(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0253850f; WORD $0x0000 // jne LBB33_52, $595(%rip) + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0xfff288e8; BYTE $0xff // callq _skip_one_fast, $-3448(%rip) + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffd2e9e8; BYTE $0xff // callq _advance_ns, $-11543(%rip) + WORD $0x2c3c // cmpb $44, %al + LONG $0xff01840f; WORD $0xffff // je LBB33_4, $-255(%rip) + LONG $0x00024de9; BYTE $0x00 // jmp LBB33_54, $589(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB33_17: + LONG $0xffe48141; WORD $0x000f; BYTE $0x00 // andl $4095, %r12d + LONG $0xf0fc8141; WORD $0x000f; BYTE $0x00 // cmpl $4080, %r12d + LONG $0x004d870f; WORD $0x0000 // ja LBB33_21, $77(%rip) + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0ff1f981; WORD $0x0000 // cmpl $4081, %ecx + LONG $0x003b830f; WORD $0x0000 // jae LBB33_21, $59(%rip) + LONG $0x006ffac5 // vmovdqu (%rax), %xmm0 + LONG $0x6f7ac1c4; WORD $0x004d // vmovdqu (%r13), %xmm1 + LONG $0xd1f8f9c5 // vpsubb %xmm1, %xmm0, %xmm2 + LONG $0x1779e2c4; BYTE $0xd2 // vptest %xmm2, %xmm2 + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0x005d840f; WORD $0x0000 // je LBB33_25, $93(%rip) + LONG $0xc174f9c5 // vpcmpeqb %xmm1, %xmm0, %xmm0 + LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax + WORD $0xd0f7 // notl %eax + LONG $0xc0bc0f66 // bsfw %ax, %ax + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x3949; BYTE $0xc7 // cmpq %rax, %r15 + WORD $0x960f; BYTE $0xc3 // setbe %bl + LONG $0xffff48e9; BYTE $0xff // jmp LBB33_14, $-184(%rip) + +LBB33_21: + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0xff36840f; WORD $0xffff // je LBB33_14, $-202(%rip) + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_23: + LONG $0x0814b60f // movzbl (%rax,%rcx), %edx + LONG $0x0d543a41; BYTE $0x00 // cmpb (%r13,%rcx), %dl + LONG $0x011d850f; WORD $0x0000 // jne LBB33_26, $285(%rip) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0xffe5850f; WORD $0xffff // jne LBB33_23, $-27(%rip) + LONG $0xffff09e9; BYTE $0xff // jmp LBB33_14, $-247(%rip) + +LBB33_25: + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0xfffeffe9; BYTE $0xff // jmp LBB33_14, $-257(%rip) + +LBB33_27: + QUAD $0x00000000b845c748 // movq $0, $-72(%rbp) + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + WORD $0x0149; BYTE $0xcc // addq %rcx, %r12 + LONG $0xc065894c // movq %r12, $-64(%rbp) + LONG $0x01348d48 // leaq (%rcx,%rax), %rsi + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x2f3c8d4b // leaq (%r15,%r13), %rdi + WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 + LONG $0x00c9830f; WORD $0x0000 // jae LBB33_44, $201(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x00c08e0f; WORD $0x0000 // jle LBB33_44, $192(%rip) + LONG $0xb8558d48 // leaq $-72(%rbp), %rdx + LONG $0xa8758948 // movq %rsi, $-88(%rbp) + +LBB33_30: + LONG $0x04b60f41; BYTE $0x24 // movzbl (%r12), %eax + WORD $0x5c3c // cmpb $92, %al + LONG $0x0069850f; WORD $0x0000 // jne LBB33_37, $105(%rip) + WORD $0x8948; BYTE $0xfb // movq %rdi, %rbx + LONG $0xc07d8d48 // leaq $-64(%rbp), %rdi + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0x001e13e8; BYTE $0x00 // callq _unescape, $7699(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0168880f; WORD $0x0000 // js LBB33_57, $360(%rip) + LONG $0x280c8d48 // leaq (%rax,%rbp), %rcx + LONG $0xb8c18348 // addq $-72, %rcx + WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi + WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0x0052830f; WORD $0x0000 // jae LBB33_39, $82(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0x0049840f; WORD $0x0000 // je LBB33_40, $73(%rip) + +LBB33_34: + LONG $0x5db60f41; BYTE $0x00 // movzbl (%r13), %ebx + WORD $0x183a // cmpb (%rax), %bl + LONG $0x003c850f; WORD $0x0000 // jne LBB33_40, $60(%rip) + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xfd // cmpq %rdi, %r13 + LONG $0x002d830f; WORD $0x0000 // jae LBB33_40, $45(%rip) + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0xffdb820f; WORD $0xffff // jb LBB33_34, $-37(%rip) + LONG $0x00001fe9; BYTE $0x00 // jmp LBB33_40, $31(%rip) + +LBB33_37: + LONG $0x00453a41 // cmpb (%r13), %al + LONG $0xfe42850f; WORD $0xffff // jne LBB33_12, $-446(%rip) + WORD $0xff49; BYTE $0xc4 // incq %r12 + LONG $0xc065894c // movq %r12, $-64(%rbp) + WORD $0xff49; BYTE $0xc5 // incq %r13 + LONG $0x000017e9; BYTE $0x00 // jmp LBB33_42, $23(%rip) + +LBB33_39: + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + +LBB33_40: + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x002d850f; WORD $0x0000 // jne LBB33_26, $45(%rip) + LONG $0xc0658b4c // movq $-64(%rbp), %r12 + LONG $0xa8758b48 // movq $-88(%rbp), %rsi + +LBB33_42: + WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 + LONG $0x0009830f; WORD $0x0000 // jae LBB33_44, $9(%rip) + WORD $0x3949; BYTE $0xfd // cmpq %rdi, %r13 + LONG $0xff48820f; WORD $0xffff // jb LBB33_30, $-184(%rip) + +LBB33_44: + WORD $0x3149; BYTE $0xf4 // xorq %rsi, %r12 + WORD $0x3149; BYTE $0xfd // xorq %rdi, %r13 + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x094d; BYTE $0xe5 // orq %r12, %r13 + WORD $0x940f; BYTE $0xc3 // sete %bl + LONG $0xfffdf9e9; BYTE $0xff // jmp LBB33_13, $-519(%rip) + +LBB33_26: + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xfffdf6e9; BYTE $0xff // jmp LBB33_14, $-522(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_47: + WORD $0xf980; BYTE $0x02 // cmpb $2, %cl + LONG $0x0078850f; WORD $0x0000 // jne LBB33_54, $120(%rip) + WORD $0x5b3c // cmpb $91, %al + LONG $0x0070850f; WORD $0x0000 // jne LBB33_54, $112(%rip) + LONG $0x08478b49 // movq $8(%r15), %rax + WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_50: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00348e0f; WORD $0x0000 // jle LBB33_52, $52(%rip) + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0xfff069e8; BYTE $0xff // callq _skip_one_fast, $-3991(%rip) + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffd0cae8; BYTE $0xff // callq _advance_ns, $-12086(%rip) + WORD $0x2c3c // cmpb $44, %al + LONG $0xffd2840f; WORD $0xffff // je LBB33_50, $-46(%rip) + LONG $0x00002ee9; BYTE $0x00 // jmp LBB33_54, $46(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_52: + LONG $0x10c78349 // addq $16, %r15 + LONG $0xa0458b48 // movq $-96(%rbp), %rax + WORD $0x3949; BYTE $0xc7 // cmpq %rax, %r15 + LONG $0xfc81850f; WORD $0xffff // jne LBB33_2, $-895(%rip) + +LBB33_53: + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0xfff024e8; BYTE $0xff // callq _skip_one_fast, $-4060(%rip) + LONG $0x00000be9; BYTE $0x00 // jmp LBB33_55, $11(%rip) + +LBB33_54: + LONG $0x240cff49 // decq (%r12) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + +LBB33_55: + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB33_56: + LONG $0x08468b49 // movq $8(%r14), %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffffdee9; BYTE $0xff // jmp LBB33_55, $-34(%rip) + +LBB33_57: + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x2b49; BYTE $0x0e // subq (%r14), %rcx + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0xffffcbe9; BYTE $0xff // jmp LBB33_55, $-53(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_validate_utf8: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x1a048d4f // leaq (%r10,%r11), %r8 + LONG $0xfdc08349 // addq $-3, %r8 + LONG $0x00000de9; BYTE $0x00 // jmp LBB34_1, $13(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB34_19: + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + +LBB34_1: + WORD $0x394c; BYTE $0xc1 // cmpq %r8, %rcx + LONG $0x00e1830f; WORD $0x0000 // jae LBB34_2, $225(%rip) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) + LONG $0xffe6890f; WORD $0xffff // jns LBB34_19, $-26(%rip) + WORD $0x018b // movl (%rcx), %eax + WORD $0xc789 // movl %eax, %edi + LONG $0xc0f0e781; WORD $0x00c0 // andl $12632304, %edi + LONG $0x80e0ff81; WORD $0x0080 // cmpl $8421600, %edi + LONG $0x0030850f; WORD $0x0000 // jne LBB34_10, $48(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi + LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi + LONG $0x001c840f; WORD $0x0000 // je LBB34_10, $28(%rip) + LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx + WORD $0xff85 // testl %edi, %edi + LONG $0xffaf850f; WORD $0xffff // jne LBB34_19, $-81(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB34_10: + WORD $0xc789 // movl %eax, %edi + LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi + LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi + LONG $0x0010850f; WORD $0x0000 // jne LBB34_12, $16(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx + WORD $0xe783; BYTE $0x1e // andl $30, %edi + LONG $0xff7c850f; WORD $0xffff // jne LBB34_19, $-132(%rip) + +LBB34_12: + WORD $0xc789 // movl %eax, %edi + LONG $0xc0f8e781; WORD $0xc0c0 // andl $-1061109512, %edi + LONG $0x80f0ff81; WORD $0x8080 // cmpl $-2139062032, %edi + LONG $0x0026850f; WORD $0x0000 // jne LBB34_16, $38(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0x3007e781; WORD $0x0000 // andl $12295, %edi + LONG $0x0018840f; WORD $0x0000 // je LBB34_16, $24(%rip) + LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx + WORD $0x04a8 // testb $4, %al + LONG $0xff4d840f; WORD $0xffff // je LBB34_19, $-179(%rip) + LONG $0x00300325; BYTE $0x00 // andl $12291, %eax + LONG $0xff42840f; WORD $0xffff // je LBB34_19, $-190(%rip) + +LBB34_16: + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x294c; BYTE $0xd7 // subq %r10, %rdi + WORD $0x8b48; BYTE $0x1a // movq (%rdx), %rbx + LONG $0x00fb8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rbx + LONG $0x0187830f; WORD $0x0000 // jae LBB34_17, $391(%rip) + WORD $0x6348; BYTE $0xc7 // movslq %edi, %rax + LONG $0x017b8d48 // leaq $1(%rbx), %rdi + WORD $0x8948; BYTE $0x3a // movq %rdi, (%rdx) + LONG $0xda448948; BYTE $0x08 // movq %rax, $8(%rdx,%rbx,8) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0xffff13e9; BYTE $0xff // jmp LBB34_19, $-237(%rip) + +LBB34_2: + WORD $0x014d; BYTE $0xd3 // addq %r10, %r11 + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x013e830f; WORD $0x0000 // jae LBB34_36, $318(%rip) + LONG $0xdc458d4c // leaq $-36(%rbp), %r8 + LONG $0xda4d8d4c // leaq $-38(%rbp), %r9 + LONG $0x000016e9; BYTE $0x00 // jmp LBB34_4, $22(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB34_5: + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x011b830f; WORD $0x0000 // jae LBB34_36, $283(%rip) + +LBB34_4: + WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) + LONG $0xffeb890f; WORD $0xffff // jns LBB34_5, $-21(%rip) + LONG $0x00dc45c6 // movb $0, $-36(%rbp) + LONG $0x00da45c6 // movb $0, $-38(%rbp) + WORD $0x894c; BYTE $0xdb // movq %r11, %rbx + WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0035820f; WORD $0x0000 // jb LBB34_21, $53(%rip) + LONG $0x21b60f44 // movzbl (%rcx), %r12d + LONG $0x71b60f44; BYTE $0x01 // movzbl $1(%rcx), %r14d + LONG $0xdc658844 // movb %r12b, $-36(%rbp) + LONG $0x02798d4c // leaq $2(%rcx), %r15 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x894c; BYTE $0xcf // movq %r9, %rdi + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0029840f; WORD $0x0000 // je LBB34_24, $41(%rip) + +LBB34_25: + LONG $0x07b60f41 // movzbl (%r15), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x65b60f44; BYTE $0xdc // movzbl $-36(%rbp), %r12d + LONG $0xda7db60f // movzbl $-38(%rbp), %edi + LONG $0x000017e9; BYTE $0x00 // jmp LBB34_26, $23(%rip) + +LBB34_21: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xffd7850f; WORD $0xffff // jne LBB34_25, $-41(%rip) + +LBB34_24: + WORD $0xff31 // xorl %edi, %edi + +LBB34_26: + LONG $0xc7b60f40 // movzbl %dil, %eax + WORD $0xe0c1; BYTE $0x10 // shll $16, %eax + LONG $0xdeb60f41 // movzbl %r14b, %ebx + WORD $0xe3c1; BYTE $0x08 // shll $8, %ebx + WORD $0xc309 // orl %eax, %ebx + LONG $0xfcb60f41 // movzbl %r12b, %edi + WORD $0xdf09 // orl %ebx, %edi + WORD $0xf889 // movl %edi, %eax + LONG $0xc0c0f025; BYTE $0x00 // andl $12632304, %eax + LONG $0x8080e03d; BYTE $0x00 // cmpl $8421600, %eax + LONG $0x001f850f; WORD $0x0000 // jne LBB34_29, $31(%rip) + WORD $0xf889 // movl %edi, %eax + LONG $0x00200f25; BYTE $0x00 // andl $8207, %eax + LONG $0x00200d3d; BYTE $0x00 // cmpl $8205, %eax + LONG $0x000d840f; WORD $0x0000 // je LBB34_29, $13(%rip) + LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx + WORD $0xc085 // testl %eax, %eax + LONG $0x0021850f; WORD $0x0000 // jne LBB34_34, $33(%rip) + + // .p2align 4, 0x90 +LBB34_29: + LONG $0x1ec4f641 // testb $30, %r12b + LONG $0x0028840f; WORD $0x0000 // je LBB34_31, $40(%rip) + LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi + LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx + LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi + LONG $0x0011850f; WORD $0x0000 // jne LBB34_31, $17(%rip) + +LBB34_34: + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0xff1f820f; WORD $0xffff // jb LBB34_4, $-225(%rip) + LONG $0x000035e9; BYTE $0x00 // jmp LBB34_36, $53(%rip) + +LBB34_31: + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + WORD $0x294c; BYTE $0xd0 // subq %r10, %rax + WORD $0x8b48; BYTE $0x3a // movq (%rdx), %rdi + LONG $0x00ff8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rdi + LONG $0x0034830f; WORD $0x0000 // jae LBB34_32, $52(%rip) + WORD $0x9848 // cltq + LONG $0x015f8d48 // leaq $1(%rdi), %rbx + WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) + LONG $0xfa448948; BYTE $0x08 // movq %rax, $8(%rdx,%rdi,8) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0xfee5820f; WORD $0xffff // jb LBB34_4, $-283(%rip) + +LBB34_36: + WORD $0x294c; BYTE $0xd1 // subq %r10, %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + WORD $0xc031 // xorl %eax, %eax + +LBB34_37: + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB34_32: + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffffe4e9; BYTE $0xff // jmp LBB34_37, $-28(%rip) + +LBB34_17: + WORD $0x8948; BYTE $0x3e // movq %rdi, (%rsi) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffffd5e9; BYTE $0xff // jmp LBB34_37, $-43(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_validate_utf8_fast: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + LONG $0x1a348d4b // leaq (%r10,%r11), %rsi + LONG $0xfdc68348 // addq $-3, %rsi + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0x394c; BYTE $0xd6 // cmpq %r10, %rsi + LONG $0x00dd860f; WORD $0x0000 // jbe LBB35_14, $221(%rip) + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x000013e9; BYTE $0x00 // jmp LBB35_3, $19(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_2: + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x00c2830f; WORD $0x0000 // jae LBB35_14, $194(%rip) + +LBB35_3: + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) + LONG $0xffe6890f; WORD $0xffff // jns LBB35_2, $-26(%rip) + WORD $0x388b // movl (%rax), %edi + WORD $0xf989 // movl %edi, %ecx + LONG $0xc0f0e181; WORD $0x00c0 // andl $12632304, %ecx + LONG $0x80e0f981; WORD $0x0080 // cmpl $8421600, %ecx + LONG $0x0030850f; WORD $0x0000 // jne LBB35_7, $48(%rip) + WORD $0xf989 // movl %edi, %ecx + LONG $0x200fe181; WORD $0x0000 // andl $8207, %ecx + LONG $0x200df981; WORD $0x0000 // cmpl $8205, %ecx + LONG $0x001c840f; WORD $0x0000 // je LBB35_7, $28(%rip) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + WORD $0xc985 // testl %ecx, %ecx + LONG $0xffaf850f; WORD $0xffff // jne LBB35_2, $-81(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_7: + WORD $0xf989 // movl %edi, %ecx + LONG $0xc0e0e181; WORD $0x0000 // andl $49376, %ecx + LONG $0x80c0f981; WORD $0x0000 // cmpl $32960, %ecx + LONG $0x0010850f; WORD $0x0000 // jne LBB35_9, $16(%rip) + WORD $0xf989 // movl %edi, %ecx + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + WORD $0xe183; BYTE $0x1e // andl $30, %ecx + LONG $0xff7c850f; WORD $0xffff // jne LBB35_2, $-132(%rip) + +LBB35_9: + WORD $0xf989 // movl %edi, %ecx + LONG $0xc0f8e181; WORD $0xc0c0 // andl $-1061109512, %ecx + LONG $0x80f0f981; WORD $0x8080 // cmpl $-2139062032, %ecx + LONG $0x0029850f; WORD $0x0000 // jne LBB35_13, $41(%rip) + WORD $0xf989 // movl %edi, %ecx + LONG $0x3007e181; WORD $0x0000 // andl $12295, %ecx + LONG $0x001b840f; WORD $0x0000 // je LBB35_13, $27(%rip) + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + LONG $0x04c7f640 // testb $4, %dil + LONG $0xff4b840f; WORD $0xffff // je LBB35_2, $-181(%rip) + LONG $0x3003e781; WORD $0x0000 // andl $12291, %edi + LONG $0xff3f840f; WORD $0xffff // je LBB35_2, $-193(%rip) + +LBB35_13: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xd0 // addq %r10, %rax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB35_14: + WORD $0x014d; BYTE $0xd3 // addq %r10, %r11 + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x0103830f; WORD $0x0000 // jae LBB35_30, $259(%rip) + LONG $0xf4458d4c // leaq $-12(%rbp), %r8 + LONG $0xf24d8d4c // leaq $-14(%rbp), %r9 + LONG $0x000015e9; BYTE $0x00 // jmp LBB35_17, $21(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_16: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x00e1830f; WORD $0x0000 // jae LBB35_30, $225(%rip) + +LBB35_17: + WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) + LONG $0xffeb890f; WORD $0xffff // jns LBB35_16, $-21(%rip) + LONG $0x00f445c6 // movb $0, $-12(%rbp) + LONG $0x00f245c6 // movb $0, $-14(%rbp) + WORD $0x894c; BYTE $0xda // movq %r11, %rdx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0031820f; WORD $0x0000 // jb LBB35_21, $49(%rip) + WORD $0xb60f; BYTE $0x30 // movzbl (%rax), %esi + LONG $0x0178b60f // movzbl $1(%rax), %edi + LONG $0xf4758840 // movb %sil, $-12(%rbp) + LONG $0x02488d48 // leaq $2(%rax), %rcx + LONG $0xfec28348 // addq $-2, %rdx + WORD $0x894c; BYTE $0xcb // movq %r9, %rbx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0025840f; WORD $0x0000 // je LBB35_22, $37(%rip) + +LBB35_20: + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + WORD $0x0b88 // movb %cl, (%rbx) + LONG $0xf475b60f // movzbl $-12(%rbp), %esi + LONG $0xf24db60f // movzbl $-14(%rbp), %ecx + LONG $0x000015e9; BYTE $0x00 // jmp LBB35_23, $21(%rip) + +LBB35_21: + WORD $0xf631 // xorl %esi, %esi + WORD $0xff31 // xorl %edi, %edi + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffdb850f; WORD $0xffff // jne LBB35_20, $-37(%rip) + +LBB35_22: + WORD $0xc931 // xorl %ecx, %ecx + +LBB35_23: + WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx + WORD $0xe1c1; BYTE $0x10 // shll $16, %ecx + LONG $0xffb60f40 // movzbl %dil, %edi + WORD $0xe7c1; BYTE $0x08 // shll $8, %edi + WORD $0xcf09 // orl %ecx, %edi + LONG $0xd6b60f40 // movzbl %sil, %edx + WORD $0xfa09 // orl %edi, %edx + WORD $0xd189 // movl %edx, %ecx + LONG $0xc0f0e181; WORD $0x00c0 // andl $12632304, %ecx + LONG $0x80e0f981; WORD $0x0080 // cmpl $8421600, %ecx + LONG $0x0024850f; WORD $0x0000 // jne LBB35_26, $36(%rip) + WORD $0xd789 // movl %edx, %edi + LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi + LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi + LONG $0x0010840f; WORD $0x0000 // je LBB35_26, $16(%rip) + LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx + WORD $0xff85 // testl %edi, %edi + LONG $0x0024850f; WORD $0x0000 // jne LBB35_28, $36(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_26: + LONG $0x1ec6f640 // testb $30, %sil + LONG $0xff07840f; WORD $0xffff // je LBB35_13, $-249(%rip) + LONG $0xc0e0e281; WORD $0x0000 // andl $49376, %edx + LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx + LONG $0x80c0fa81; WORD $0x0000 // cmpl $32960, %edx + LONG $0xfef0850f; WORD $0xffff // jne LBB35_13, $-272(%rip) + +LBB35_28: + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0xff1f820f; WORD $0xffff // jb LBB35_17, $-225(%rip) + +LBB35_30: + WORD $0xc031 // xorl %eax, %eax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; WORD $0x0000 // .p2align 5, 0x00 + +LCPI36_0: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x00 +LCPI36_1: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x90 +_f32toa: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + LONG $0xc07ef9c5 // vmovd %xmm0, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x17 // shrl $23, %ecx + WORD $0xb60f; BYTE $0xd1 // movzbl %cl, %edx + LONG $0x00fffa81; WORD $0x0000 // cmpl $255, %edx + LONG $0x0df0840f; WORD $0x0000 // je LBB36_141, $3568(%rip) + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d + LONG $0x1fe9c141 // shrl $31, %r9d + LONG $0x0f2c8d4e // leaq (%rdi,%r9), %r13 + LONG $0xffffffa9; BYTE $0x7f // testl $2147483647, %eax + LONG $0x01cd840f; WORD $0x0000 // je LBB36_6, $461(%rip) + LONG $0x7fffff25; BYTE $0x00 // andl $8388607, %eax + WORD $0xd285 // testl %edx, %edx + LONG $0x0dd1840f; WORD $0x0000 // je LBB36_142, $3537(%rip) + LONG $0x00b88d44; WORD $0x8000; BYTE $0x00 // leal $8388608(%rax), %r15d + LONG $0x6a828d44; WORD $0xffff; BYTE $0xff // leal $-150(%rdx), %r8d + WORD $0x4a8d; BYTE $0x81 // leal $-127(%rdx), %ecx + WORD $0xf983; BYTE $0x17 // cmpl $23, %ecx + LONG $0x001c870f; WORD $0x0000 // ja LBB36_7, $28(%rip) + LONG $0x000096b9; BYTE $0x00 // movl $150, %ecx + WORD $0xd129 // subl %edx, %ecx + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx + WORD $0xd3f7 // notl %ebx + WORD $0x8544; BYTE $0xfb // testl %r15d, %ebx + LONG $0x043c840f; WORD $0x0000 // je LBB36_33, $1084(%rip) + +LBB36_7: + LONG $0xd07d8948 // movq %rdi, $-48(%rbp) + +LBB36_8: + WORD $0x8945; BYTE $0xfe // movl %r15d, %r14d + LONG $0x01e68341 // andl $1, %r14d + WORD $0xc085 // testl %eax, %eax + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0xfa83; BYTE $0x02 // cmpl $2, %edx + WORD $0x930f; BYTE $0xc1 // setae %cl + WORD $0xc120 // andb %al, %cl + WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx + WORD $0x8945; BYTE $0xfa // movl %r15d, %r10d + LONG $0x02e2c141 // shll $2, %r10d + LONG $0xb9048d42 // leal (%rcx,%r15,4), %eax + WORD $0xc083; BYTE $0xfe // addl $-2, %eax + LONG $0x13d06941; WORD $0x1344; BYTE $0x00 // imull $1262611, %r8d, %edx + LONG $0x019a8d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rdx), %r11d + WORD $0xc984 // testb %cl, %cl + LONG $0xda440f44 // cmovel %edx, %r11d + LONG $0x16fbc141 // sarl $22, %r11d + LONG $0xb1cb6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r11d, %ecx + WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx + WORD $0x0144; BYTE $0xc1 // addl %r8d, %ecx + LONG $0x00001fba; BYTE $0x00 // movl $31, %edx + WORD $0x2944; BYTE $0xda // subl %r11d, %edx + LONG $0xc13d8d48; WORD $0x00b8; BYTE $0x00 // leaq $47297(%rip), %rdi /* _pow10_ceil_sig_f32.g(%rip) */ + WORD $0xc1fe // incb %cl + WORD $0xe0d3 // shll %cl, %eax + LONG $0xd7248b4c // movq (%rdi,%rdx,8), %r12 + WORD $0xf749; BYTE $0xe4 // mulq %r12 + QUAD $0x00000002bd048d46 // leal $2(,%r15,4), %r8d + WORD $0xf631 // xorl %esi, %esi + LONG $0x21e8c148 // shrq $33, %rax + LONG $0xc6950f40 // setne %sil + WORD $0xd609 // orl %edx, %esi + WORD $0xd341; BYTE $0xe2 // shll %cl, %r10d + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0xf749; BYTE $0xe4 // mulq %r12 + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + LONG $0x21e8c148 // shrq $33, %rax + LONG $0xc7950f41 // setne %r15b + WORD $0x0945; BYTE $0xd7 // orl %r10d, %r15d + WORD $0xd341; BYTE $0xe0 // shll %cl, %r8d + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0xf749; BYTE $0xe4 // mulq %r12 + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x21e8c148 // shrq $33, %rax + WORD $0x950f; BYTE $0xc1 // setne %cl + WORD $0xd109 // orl %edx, %ecx + WORD $0x0144; BYTE $0xf6 // addl %r14d, %esi + WORD $0x2944; BYTE $0xf1 // subl %r14d, %ecx + LONG $0x28ff8341 // cmpl $40, %r15d + LONG $0x0041820f; WORD $0x0000 // jb LBB36_10, $65(%rip) + WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax + LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx + LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xf089 // movl %esi, %eax + QUAD $0x00000000d53c8d48 // leaq (,%rdx,8), %rdi + LONG $0xbf1c8d48 // leaq (%rdi,%rdi,4), %rbx + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0xc6920f41 // setb %r14b + LONG $0xbf3c8d48 // leaq (%rdi,%rdi,4), %rdi + LONG $0x28c78348 // addq $40, %rdi + WORD $0xcb89 // movl %ecx, %ebx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xdf // cmpq %rbx, %rdi + LONG $0xc0960f41 // setbe %r8b + WORD $0x3845; BYTE $0xc6 // cmpb %r8b, %r14b + LONG $0x01f9840f; WORD $0x0000 // je LBB36_18, $505(%rip) + +LBB36_10: + WORD $0x8945; BYTE $0xd0 // movl %r10d, %r8d + LONG $0x02e8c141 // shrl $2, %r8d + WORD $0x8944; BYTE $0xd2 // movl %r10d, %edx + WORD $0xe283; BYTE $0xfc // andl $-4, %edx + WORD $0xd639 // cmpl %edx, %esi + LONG $0xc6970f40 // seta %sil + WORD $0x428d; BYTE $0x04 // leal $4(%rdx), %eax + WORD $0xc839 // cmpl %ecx, %eax + WORD $0x960f; BYTE $0xc3 // setbe %bl + WORD $0x3040; BYTE $0xf3 // xorb %sil, %bl + LONG $0x007e840f; WORD $0x0000 // je LBB36_14, $126(%rip) + WORD $0xca83; BYTE $0x02 // orl $2, %edx + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x3941; BYTE $0xd7 // cmpl %edx, %r15d + LONG $0x000e870f; WORD $0x0000 // ja LBB36_13, $14(%rip) + WORD $0x940f; BYTE $0xc0 // sete %al + LONG $0x02eac041 // shrb $2, %r10b + WORD $0x2041; BYTE $0xc2 // andb %al, %r10b + LONG $0xc2b60f41 // movzbl %r10b, %eax + +LBB36_13: + WORD $0x0144; BYTE $0xc0 // addl %r8d, %eax + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax + LONG $0xd06d8b4c // movq $-48(%rbp), %r13 + LONG $0x0065820f; WORD $0x0000 // jb LBB36_19, $101(%rip) + +LBB36_15: + LONG $0x0006bc41; WORD $0x0000 // movl $6, %r12d + LONG $0x0f42403d; BYTE $0x00 // cmpl $1000000, %eax + LONG $0x0093820f; WORD $0x0000 // jb LBB36_23, $147(%rip) + LONG $0x0007bc41; WORD $0x0000 // movl $7, %r12d + LONG $0x9896803d; BYTE $0x00 // cmpl $10000000, %eax + LONG $0x0082820f; WORD $0x0000 // jb LBB36_23, $130(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xf5e1003d; BYTE $0x05 // cmpl $100000000, %eax + LONG $0xc4920f41 // setb %r12b + LONG $0x09f48341 // xorl $9, %r12d + LONG $0x00006de9; BYTE $0x00 // jmp LBB36_23, $109(%rip) + +LBB36_6: + LONG $0x0045c641; BYTE $0x30 // movb $48, (%r13) + WORD $0x2941; BYTE $0xfd // subl %edi, %r13d + WORD $0xff41; BYTE $0xc5 // incl %r13d + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + LONG $0x000be5e9; BYTE $0x00 // jmp LBB36_93, $3045(%rip) + +LBB36_14: + WORD $0xc139 // cmpl %eax, %ecx + LONG $0xffd88341 // sbbl $-1, %r8d + WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax + LONG $0xd06d8b4c // movq $-48(%rbp), %r13 + LONG $0xff9b830f; WORD $0xffff // jae LBB36_15, $-101(%rip) + +LBB36_19: + LONG $0x0001bc41; WORD $0x0000 // movl $1, %r12d + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x0030820f; WORD $0x0000 // jb LBB36_23, $48(%rip) + LONG $0x0002bc41; WORD $0x0000 // movl $2, %r12d + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0x0021820f; WORD $0x0000 // jb LBB36_23, $33(%rip) + LONG $0x0003bc41; WORD $0x0000 // movl $3, %r12d + LONG $0x0003e83d; BYTE $0x00 // cmpl $1000, %eax + LONG $0x0010820f; WORD $0x0000 // jb LBB36_23, $16(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0xc4920f41 // setb %r12b + LONG $0x05f48341 // xorl $5, %r12d + +LBB36_23: + LONG $0x1c148d47 // leal (%r12,%r11), %r10d + LONG $0x1c0c8d43 // leal (%r12,%r11), %ecx + WORD $0xc183; BYTE $0xea // addl $-22, %ecx + WORD $0xf983; BYTE $0xe4 // cmpl $-28, %ecx + LONG $0x0077870f; WORD $0x0000 // ja LBB36_27, $119(%rip) + WORD $0x8944; BYTE $0xe1 // movl %r12d, %ecx + LONG $0x0f148d49 // leaq (%r15,%rcx), %rdx + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0x00f3820f; WORD $0x0000 // jb LBB36_31, $243(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0xb71759be; BYTE $0xd1 // movl $3518437209, %esi + LONG $0xf7af0f48 // imulq %rdi, %rsi + LONG $0x2deec148 // shrq $45, %rsi + LONG $0xf0c66944; WORD $0xffd8; BYTE $0xff // imull $-10000, %esi, %r8d + WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d + LONG $0x0464840f; WORD $0x0000 // je LBB36_59, $1124(%rip) + WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi + WORD $0x2941; BYTE $0xf8 // subl %edi, %r8d + LONG $0x443d8d48; WORD $0x0043; BYTE $0x00 // leaq $17220(%rip), %rdi /* _Digits(%rip) */ + LONG $0x1cb70f42; BYTE $0x47 // movzwl (%rdi,%r8,2), %ebx + LONG $0xfe5a8966 // movw %bx, $-2(%rdx) + LONG $0x4704b70f // movzwl (%rdi,%rax,2), %eax + LONG $0xfc428966 // movw %ax, $-4(%rdx) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x00a6830f; WORD $0x0000 // jae LBB36_61, $166(%rip) + +LBB36_32: + WORD $0xf089 // movl %esi, %eax + LONG $0x0000dbe9; BYTE $0x00 // jmp LBB36_63, $219(%rip) + +LBB36_27: + WORD $0x8945; BYTE $0xe0 // movl %r12d, %r8d + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x023a880f; WORD $0x0000 // js LBB36_36, $570(%rip) + LONG $0x070c8d4b // leaq (%r15,%r8), %rcx + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0x0295820f; WORD $0x0000 // jb LBB36_41, $661(%rip) + WORD $0xc289 // movl %eax, %edx + LONG $0xb71759be; BYTE $0xd1 // movl $3518437209, %esi + LONG $0xf2af0f48 // imulq %rdx, %rsi + LONG $0x2deec148 // shrq $45, %rsi + LONG $0xd8f0d669; WORD $0xffff // imull $-10000, %esi, %edx + WORD $0xc201 // addl %eax, %edx + LONG $0x1fc26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi + WORD $0xfa29 // subl %edi, %edx + LONG $0xd33d8d48; WORD $0x0042; BYTE $0x00 // leaq $17107(%rip), %rdi /* _Digits(%rip) */ + LONG $0x5714b70f // movzwl (%rdi,%rdx,2), %edx + LONG $0xfe518966 // movw %dx, $-2(%rcx) + LONG $0xfc518d48 // leaq $-4(%rcx), %rdx + LONG $0x4704b70f // movzwl (%rdi,%rax,2), %eax + LONG $0xfc418966 // movw %ax, $-4(%rcx) + WORD $0xf089 // movl %esi, %eax + WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0x0254830f; WORD $0x0000 // jae LBB36_42, $596(%rip) + +LBB36_30: + WORD $0xc689 // movl %eax, %esi + LONG $0x000288e9; BYTE $0x00 // jmp LBB36_44, $648(%rip) + +LBB36_18: + WORD $0x8844; BYTE $0xc0 // movb %r8b, %al + WORD $0xd001 // addl %edx, %eax + WORD $0xff41; BYTE $0xc3 // incl %r11d + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax + LONG $0xd06d8b4c // movq $-48(%rbp), %r13 + LONG $0xfe45830f; WORD $0xffff // jae LBB36_15, $-443(%rip) + LONG $0xfffea5e9; BYTE $0xff // jmp LBB36_19, $-347(%rip) + +LBB36_31: + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xc689 // movl %eax, %esi + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0xff5a820f; WORD $0xffff // jb LBB36_32, $-166(%rip) + +LBB36_61: + WORD $0xff48; BYTE $0xca // decq %rdx + LONG $0x731d8d4c; WORD $0x0042; BYTE $0x00 // leaq $17011(%rip), %r11 /* _Digits(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_62: + WORD $0xf089 // movl %esi, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi + WORD $0xf389 // movl %esi, %ebx + WORD $0xfb29 // subl %edi, %ebx + LONG $0x3cb70f41; BYTE $0x5b // movzwl (%r11,%rbx,2), %edi + LONG $0xff7a8966 // movw %di, $-1(%rdx) + LONG $0xfec28348 // addq $-2, %rdx + LONG $0x270ffe81; WORD $0x0000 // cmpl $9999, %esi + WORD $0xc689 // movl %eax, %esi + LONG $0xffd1870f; WORD $0xffff // ja LBB36_62, $-47(%rip) + +LBB36_63: + LONG $0x01578d49 // leaq $1(%r15), %rdx + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x001f820f; WORD $0x0000 // jb LBB36_65, $31(%rip) + WORD $0xc689 // movl %eax, %esi + LONG $0x2b3d8d48; WORD $0x0042; BYTE $0x00 // leaq $16939(%rip), %rdi /* _Digits(%rip) */ + LONG $0x7704b60f // movzbl (%rdi,%rsi,2), %eax + LONG $0x775cb60f; BYTE $0x01 // movzbl $1(%rdi,%rsi,2), %ebx + LONG $0x01478841 // movb %al, $1(%r15) + LONG $0x025f8841 // movb %bl, $2(%r15) + LONG $0x000004e9; BYTE $0x00 // jmp LBB36_66, $4(%rip) + +LBB36_65: + WORD $0x3004 // addb $48, %al + WORD $0x0288 // movb %al, (%rdx) + +LBB36_66: + WORD $0x294d; BYTE $0xc1 // subq %r8, %r9 + WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 + LONG $0x000001be; BYTE $0x00 // movl $1, %esi + WORD $0x294c; BYTE $0xc6 // subq %r8, %rsi + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_67: + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x093c8041; BYTE $0x30 // cmpb $48, (%r9,%rcx) + LONG $0xff498d4d // leaq $-1(%r9), %r9 + LONG $0xffee840f; WORD $0xffff // je LBB36_67, $-18(%rip) + WORD $0x8841; BYTE $0x07 // movb %al, (%r15) + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x00458c0f; WORD $0x0000 // jl LBB36_72, $69(%rip) + LONG $0x09048d49 // leaq (%r9,%rcx), %rax + LONG $0x02c08348 // addq $2, %rax + WORD $0x02c6; BYTE $0x2e // movb $46, (%rdx) + WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00418e0f; WORD $0x0000 // jle LBB36_73, $65(%rip) + +LBB36_70: + WORD $0xff41; BYTE $0xca // decl %r10d + LONG $0x2b0140c6 // movb $43, $1(%rax) + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0x0043820f; WORD $0x0000 // jb LBB36_74, $67(%rip) + +LBB36_71: + WORD $0x6348; BYTE $0xc9 // movslq %ecx, %rcx + LONG $0xaa158d48; WORD $0x0041; BYTE $0x00 // leaq $16810(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x02488966 // movw %cx, $2(%rax) + LONG $0x04c08348 // addq $4, %rax + LONG $0x00097ae9; BYTE $0x00 // jmp LBB36_92, $2426(%rip) + +LBB36_72: + LONG $0x09048d49 // leaq (%r9,%rcx), %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0xffbf8f0f; WORD $0xffff // jg LBB36_70, $-65(%rip) + +LBB36_73: + LONG $0x2d0140c6 // movb $45, $1(%rax) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + WORD $0x2944; BYTE $0xd1 // subl %r10d, %ecx + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0xffbd830f; WORD $0xffff // jae LBB36_71, $-67(%rip) + +LBB36_74: + WORD $0xc180; BYTE $0x30 // addb $48, %cl + WORD $0x4888; BYTE $0x02 // movb %cl, $2(%rax) + LONG $0x03c08348 // addq $3, %rax + LONG $0x000943e9; BYTE $0x00 // jmp LBB36_92, $2371(%rip) + +LBB36_33: + WORD $0xd341; BYTE $0xef // shrl %cl, %r15d + LONG $0xa0ff8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r15d + LONG $0x01a8820f; WORD $0x0000 // jb LBB36_50, $424(%rip) + LONG $0x80ff8141; WORD $0x9896; BYTE $0x00 // cmpl $10000000, %r15d + LONG $0x000008b8; BYTE $0x00 // movl $8, %eax + LONG $0x00d88348 // sbbq $0, %rax + LONG $0x40ff8141; WORD $0x0f42; BYTE $0x00 // cmpl $1000000, %r15d + LONG $0x000006b9; BYTE $0x00 // movl $6, %ecx + LONG $0xc8430f48 // cmovaeq %rax, %rcx + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx + +LBB36_35: + WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax + LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx + LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0xd8f0c269; WORD $0xffff // imull $-10000, %edx, %eax + WORD $0x0144; BYTE $0xf8 // addl %r15d, %eax + LONG $0x1ff06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rsi + LONG $0x25eec148 // shrq $37, %rsi + WORD $0xde6b; BYTE $0x64 // imull $100, %esi, %ebx + WORD $0xd829 // subl %ebx, %eax + LONG $0xff1d8d48; WORD $0x0040; BYTE $0x00 // leaq $16639(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4304b70f // movzwl (%rbx,%rax,2), %eax + LONG $0xfe418966 // movw %ax, $-2(%rcx) + LONG $0x7304b70f // movzwl (%rbx,%rsi,2), %eax + LONG $0xfc418966 // movw %ax, $-4(%rcx) + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xfcc18348 // addq $-4, %rcx + WORD $0x8941; BYTE $0xd7 // movl %edx, %r15d + LONG $0x64ff8341 // cmpl $100, %r15d + LONG $0x0171830f; WORD $0x0000 // jae LBB36_54, $369(%rip) + LONG $0x0001a8e9; BYTE $0x00 // jmp LBB36_56, $424(%rip) + +LBB36_36: + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x04dc8f0f; WORD $0x0000 // jg LBB36_102, $1244(%rip) + LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) + LONG $0x02c78349 // addq $2, %r15 + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x04c9890f; WORD $0x0000 // jns LBB36_102, $1225(%rip) + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + WORD $0xf741; BYTE $0xd6 // notl %r14d + WORD $0x2945; BYTE $0xde // subl %r11d, %r14d + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x7ffe8341 // cmpl $127, %r14d + LONG $0x049d820f; WORD $0x0000 // jb LBB36_100, $1181(%rip) + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + LONG $0x80e18348 // andq $-128, %rcx + LONG $0x80518d48 // leaq $-128(%rcx), %rdx + WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 + LONG $0x07edc149 // shrq $7, %r13 + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x8945; BYTE $0xef // movl %r13d, %r15d + LONG $0x03e78341 // andl $3, %r15d + LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdx + LONG $0x036a830f; WORD $0x0000 // jae LBB36_94, $874(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x00040de9; BYTE $0x00 // jmp LBB36_96, $1037(%rip) + +LBB36_41: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0xfdac820f; WORD $0xffff // jb LBB36_30, $-596(%rip) + +LBB36_42: + WORD $0xff48; BYTE $0xca // decq %rdx + LONG $0x53358d4c; WORD $0x0040; BYTE $0x00 // leaq $16467(%rip), %r14 /* _Digits(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_43: + WORD $0xc689 // movl %eax, %esi + LONG $0x1ff66948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %rsi + LONG $0x25eec148 // shrq $37, %rsi + WORD $0xfe6b; BYTE $0x64 // imull $100, %esi, %edi + WORD $0xc389 // movl %eax, %ebx + WORD $0xfb29 // subl %edi, %ebx + LONG $0x3cb70f41; BYTE $0x5e // movzwl (%r14,%rbx,2), %edi + LONG $0xff7a8966 // movw %di, $-1(%rdx) + LONG $0xfec28348 // addq $-2, %rdx + LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax + WORD $0xf089 // movl %esi, %eax + LONG $0xffd2870f; WORD $0xffff // ja LBB36_43, $-46(%rip) + +LBB36_44: + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0x0022820f; WORD $0x0000 // jb LBB36_46, $34(%rip) + WORD $0xf089 // movl %esi, %eax + LONG $0x10158d48; WORD $0x0040; BYTE $0x00 // leaq $16400(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4204b70f // movzwl (%rdx,%rax,2), %eax + LONG $0x07894166 // movw %ax, (%r15) + WORD $0x014d; BYTE $0xdf // addq %r11, %r15 + WORD $0x3945; BYTE $0xd4 // cmpl %r10d, %r12d + LONG $0x0018820f; WORD $0x0000 // jb LBB36_47, $24(%rip) + LONG $0x0002e6e9; BYTE $0x00 // jmp LBB36_91, $742(%rip) + +LBB36_46: + LONG $0x30c68040 // addb $48, %sil + WORD $0x8841; BYTE $0x37 // movb %sil, (%r15) + WORD $0x014d; BYTE $0xdf // addq %r11, %r15 + WORD $0x3945; BYTE $0xd4 // cmpl %r10d, %r12d + LONG $0x02d3830f; WORD $0x0000 // jae LBB36_91, $723(%rip) + +LBB36_47: + LONG $0x29048d4b // leaq (%r9,%r13), %rax + LONG $0x00148d49 // leaq (%r8,%rax), %rdx + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + WORD $0x394c; BYTE $0xda // cmpq %r11, %rdx + LONG $0xda470f4c // cmovaq %rdx, %r11 + WORD $0x014c; BYTE $0xc0 // addq %r8, %rax + WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 + LONG $0x10fb8349 // cmpq $16, %r11 + LONG $0x029f820f; WORD $0x0000 // jb LBB36_90, $671(%rip) + LONG $0x80fb8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r11 + LONG $0x00cf830f; WORD $0x0000 // jae LBB36_75, $207(%rip) + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x000211e9; BYTE $0x00 // jmp LBB36_84, $529(%rip) + +LBB36_50: + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x0aff8341 // cmpl $10, %r15d + LONG $0x0021820f; WORD $0x0000 // jb LBB36_53, $33(%rip) + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + LONG $0x64ff8341 // cmpl $100, %r15d + LONG $0x0012820f; WORD $0x0000 // jb LBB36_53, $18(%rip) + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + LONG $0xe7ff8141; WORD $0x0003; BYTE $0x00 // cmpl $999, %r15d + LONG $0x022b870f; WORD $0x0000 // ja LBB36_87, $555(%rip) + +LBB36_53: + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + LONG $0x64ff8341 // cmpl $100, %r15d + LONG $0x003c820f; WORD $0x0000 // jb LBB36_56, $60(%rip) + +LBB36_54: + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0x60058d4c; WORD $0x003f; BYTE $0x00 // leaq $16224(%rip), %r8 /* _Digits(%rip) */ + + // .p2align 4, 0x90 +LBB36_55: + WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx + WORD $0x8944; BYTE $0xfe // movl %r15d, %esi + LONG $0x1ffe694c; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %r15 + LONG $0x25efc149 // shrq $37, %r15 + LONG $0x64f76b41 // imull $100, %r15d, %esi + WORD $0xda89 // movl %ebx, %edx + WORD $0xf229 // subl %esi, %edx + LONG $0x14b70f41; BYTE $0x50 // movzwl (%r8,%rdx,2), %edx + LONG $0xff518966 // movw %dx, $-1(%rcx) + LONG $0xfec18348 // addq $-2, %rcx + LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx + LONG $0xffce870f; WORD $0xffff // ja LBB36_55, $-50(%rip) + +LBB36_56: + LONG $0x0aff8341 // cmpl $10, %r15d + LONG $0x001a820f; WORD $0x0000 // jb LBB36_58, $26(%rip) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + LONG $0x1a158d48; WORD $0x003f; BYTE $0x00 // leaq $16154(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x4d894166; BYTE $0x00 // movw %cx, (%r13) + WORD $0xf829 // subl %edi, %eax + LONG $0x0006eee9; BYTE $0x00 // jmp LBB36_93, $1774(%rip) + +LBB36_58: + LONG $0x30c78041 // addb $48, %r15b + LONG $0x007d8845 // movb %r15b, (%r13) + WORD $0xf829 // subl %edi, %eax + LONG $0x0006dfe9; BYTE $0x00 // jmp LBB36_93, $1759(%rip) + +LBB36_59: + LONG $0x0004b841; WORD $0x0000 // movl $4, %r8d + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0xfbc5820f; WORD $0xffff // jb LBB36_32, $-1083(%rip) + LONG $0xfffc66e9; BYTE $0xff // jmp LBB36_61, $-922(%rip) + +LBB36_75: + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0x80e28349 // andq $-128, %r10 + LONG $0x80428d49 // leaq $-128(%r10), %rax + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + LONG $0x07eac148 // shrq $7, %rdx + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x8941; BYTE $0xd6 // movl %edx, %r14d + LONG $0x03e68341 // andl $3, %r14d + LONG $0x01803d48; WORD $0x0000 // cmpq $384, %rax + LONG $0x0007830f; WORD $0x0000 // jae LBB36_77, $7(%rip) + WORD $0xf631 // xorl %esi, %esi + LONG $0x0000b5e9; BYTE $0x00 // jmp LBB36_79, $181(%rip) + +LBB36_77: + LONG $0xfce28348 // andq $-4, %rdx + LONG $0x01048d4b // leaq (%r9,%r8), %rax + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + LONG $0x01e00548; WORD $0x0000 // addq $480, %rax + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff849056ffdc5 // vmovdqa $-1975(%rip), %ymm0 /* LCPI36_0(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_78: + QUAD $0xfffe2030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rax,%rsi) + QUAD $0xfffe4030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rax,%rsi) + QUAD $0xfffe6030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rax,%rsi) + QUAD $0xfffe8030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rax,%rsi) + QUAD $0xfffea030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rax,%rsi) + QUAD $0xfffec030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rax,%rsi) + QUAD $0xfffee030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rax,%rsi) + QUAD $0xffff0030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rax,%rsi) + QUAD $0xffff2030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rax,%rsi) + QUAD $0xffff4030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rax,%rsi) + QUAD $0xffff6030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rax,%rsi) + LONG $0x447ffec5; WORD $0x8030 // vmovdqu %ymm0, $-128(%rax,%rsi) + LONG $0x447ffec5; WORD $0xa030 // vmovdqu %ymm0, $-96(%rax,%rsi) + LONG $0x447ffec5; WORD $0xc030 // vmovdqu %ymm0, $-64(%rax,%rsi) + LONG $0x447ffec5; WORD $0xe030 // vmovdqu %ymm0, $-32(%rax,%rsi) + LONG $0x047ffec5; BYTE $0x30 // vmovdqu %ymm0, (%rax,%rsi) + LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq $512, %rsi + LONG $0xfcc28348 // addq $-4, %rdx + LONG $0xff6f850f; WORD $0xffff // jne LBB36_78, $-145(%rip) + +LBB36_79: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x004a840f; WORD $0x0000 // je LBB36_82, $74(%rip) + WORD $0x014c; BYTE $0xce // addq %r9, %rsi + WORD $0x014c; BYTE $0xc6 // addq %r8, %rsi + LONG $0x2e048d4a // leaq (%rsi,%r13), %rax + LONG $0x60c08348 // addq $96, %rax + LONG $0x07e6c149 // shlq $7, %r14 + WORD $0xd231 // xorl %edx, %edx + QUAD $0xfffff78a056ffdc5 // vmovdqa $-2166(%rip), %ymm0 /* LCPI36_0(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB36_81: + LONG $0x447ffec5; WORD $0xa010 // vmovdqu %ymm0, $-96(%rax,%rdx) + LONG $0x447ffec5; WORD $0xc010 // vmovdqu %ymm0, $-64(%rax,%rdx) + LONG $0x447ffec5; WORD $0xe010 // vmovdqu %ymm0, $-32(%rax,%rdx) + LONG $0x047ffec5; BYTE $0x10 // vmovdqu %ymm0, (%rax,%rdx) + LONG $0x80ea8348 // subq $-128, %rdx + WORD $0x3949; BYTE $0xd6 // cmpq %rdx, %r14 + LONG $0xffdc850f; WORD $0xffff // jne LBB36_81, $-36(%rip) + +LBB36_82: + WORD $0x394d; BYTE $0xd3 // cmpq %r10, %r11 + LONG $0x0092840f; WORD $0x0000 // je LBB36_91, $146(%rip) + LONG $0x70c3f641 // testb $112, %r11b + LONG $0x0071840f; WORD $0x0000 // je LBB36_89, $113(%rip) + +LBB36_84: + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + LONG $0xf0e08348 // andq $-16, %rax + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x014d; BYTE $0xd1 // addq %r10, %r9 + WORD $0x014d; BYTE $0xc1 // addq %r8, %r9 + WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x294c; BYTE $0xd2 // subq %r10, %rdx + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff746056ff9c5 // vmovdqa $-2234(%rip), %xmm0 /* LCPI36_1(%rip) */ + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB36_85: + LONG $0x7f7ac1c4; WORD $0x3104 // vmovdqu %xmm0, (%r9,%rsi) + LONG $0x10c68348 // addq $16, %rsi + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0xffed850f; WORD $0xffff // jne LBB36_85, $-19(%rip) + WORD $0x3949; BYTE $0xc3 // cmpq %rax, %r11 + LONG $0x0034850f; WORD $0x0000 // jne LBB36_90, $52(%rip) + LONG $0x00003ee9; BYTE $0x00 // jmp LBB36_91, $62(%rip) + +LBB36_87: + LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + LONG $0x00d98348 // sbbq $0, %rcx + LONG $0x05c18348 // addq $5, %rcx + LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d + LONG $0xfc01830f; WORD $0xffff // jae LBB36_35, $-1023(%rip) + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xfffdbee9; BYTE $0xff // jmp LBB36_54, $-578(%rip) + +LBB36_89: + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_90: + WORD $0x01c6; BYTE $0x30 // movb $48, (%rcx) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x394c; BYTE $0xf9 // cmpq %r15, %rcx + LONG $0xfff1820f; WORD $0xffff // jb LBB36_90, $-15(%rip) + +LBB36_91: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0x0004eae9; BYTE $0x00 // jmp LBB36_92, $1258(%rip) + +LBB36_94: + LONG $0xfce58349 // andq $-4, %r13 + LONG $0x39348d49 // leaq (%r9,%rdi), %rsi + LONG $0xe2c68148; WORD $0x0001; BYTE $0x00 // addq $482, %rsi + WORD $0xd231 // xorl %edx, %edx + QUAD $0xfffff6a0056ffdc5 // vmovdqa $-2400(%rip), %ymm0 /* LCPI36_0(%rip) */ + +LBB36_95: + QUAD $0xfffe2016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rsi,%rdx) + QUAD $0xfffe4016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rsi,%rdx) + QUAD $0xfffe6016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rsi,%rdx) + QUAD $0xfffe8016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rsi,%rdx) + QUAD $0xfffea016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rsi,%rdx) + QUAD $0xfffec016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rsi,%rdx) + QUAD $0xfffee016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rsi,%rdx) + QUAD $0xffff0016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rsi,%rdx) + QUAD $0xffff2016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rsi,%rdx) + QUAD $0xffff4016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rsi,%rdx) + QUAD $0xffff6016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rsi,%rdx) + LONG $0x447ffec5; WORD $0x8016 // vmovdqu %ymm0, $-128(%rsi,%rdx) + LONG $0x447ffec5; WORD $0xa016 // vmovdqu %ymm0, $-96(%rsi,%rdx) + LONG $0x447ffec5; WORD $0xc016 // vmovdqu %ymm0, $-64(%rsi,%rdx) + LONG $0x447ffec5; WORD $0xe016 // vmovdqu %ymm0, $-32(%rsi,%rdx) + LONG $0x047ffec5; BYTE $0x16 // vmovdqu %ymm0, (%rsi,%rdx) + LONG $0x00c28148; WORD $0x0002; BYTE $0x00 // addq $512, %rdx + LONG $0xfcc58349 // addq $-4, %r13 + LONG $0xff6f850f; WORD $0xffff // jne LBB36_95, $-145(%rip) + +LBB36_96: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + WORD $0x8949; BYTE $0xfd // movq %rdi, %r13 + LONG $0x003c840f; WORD $0x0000 // je LBB36_99, $60(%rip) + WORD $0x014c; BYTE $0xca // addq %r9, %rdx + WORD $0x014c; BYTE $0xea // addq %r13, %rdx + LONG $0x62c28348 // addq $98, %rdx + LONG $0x07e7c149 // shlq $7, %r15 + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff5eb056ffdc5 // vmovdqa $-2581(%rip), %ymm0 /* LCPI36_0(%rip) */ + +LBB36_98: + LONG $0x447ffec5; WORD $0xa032 // vmovdqu %ymm0, $-96(%rdx,%rsi) + LONG $0x447ffec5; WORD $0xc032 // vmovdqu %ymm0, $-64(%rdx,%rsi) + LONG $0x447ffec5; WORD $0xe032 // vmovdqu %ymm0, $-32(%rdx,%rsi) + LONG $0x047ffec5; BYTE $0x32 // vmovdqu %ymm0, (%rdx,%rsi) + LONG $0x80ee8348 // subq $-128, %rsi + WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 + LONG $0xffdc850f; WORD $0xffff // jne LBB36_98, $-36(%rip) + +LBB36_99: + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x0017840f; WORD $0x0000 // je LBB36_102, $23(%rip) + +LBB36_100: + WORD $0x0144; BYTE $0xd1 // addl %r10d, %ecx + WORD $0xd9f7 // negl %ecx + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_101: + LONG $0x3007c641 // movb $48, (%r15) + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xc9ff // decl %ecx + LONG $0xfff1850f; WORD $0xffff // jne LBB36_101, $-15(%rip) + +LBB36_102: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0x005f820f; WORD $0x0000 // jb LBB36_105, $95(%rip) + WORD $0xc289 // movl %eax, %edx + LONG $0xb71759bb; BYTE $0xd1 // movl $3518437209, %ebx + LONG $0xdaaf0f48 // imulq %rdx, %rbx + LONG $0x2debc148 // shrq $45, %rbx + LONG $0xd8f0d369; WORD $0xffff // imull $-10000, %ebx, %edx + WORD $0xc201 // addl %eax, %edx + LONG $0x01c3840f; WORD $0x0000 // je LBB36_107, $451(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf06b; BYTE $0x64 // imull $100, %eax, %esi + WORD $0xf229 // subl %esi, %edx + LONG $0xa9358d48; WORD $0x003b; BYTE $0x00 // leaq $15273(%rip), %rsi /* _Digits(%rip) */ + LONG $0x5614b70f // movzwl (%rsi,%rdx,2), %edx + LONG $0x57894166; BYTE $0xfe // movw %dx, $-2(%r15) + LONG $0x4604b70f // movzwl (%rsi,%rax,2), %eax + LONG $0x47894166; BYTE $0xfc // movw %ax, $-4(%r15) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0xfc578d49 // leaq $-4(%r15), %rdx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0x0018830f; WORD $0x0000 // jae LBB36_109, $24(%rip) + +LBB36_106: + WORD $0xd889 // movl %ebx, %eax + LONG $0x00004ee9; BYTE $0x00 // jmp LBB36_111, $78(%rip) + +LBB36_105: + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0xc389 // movl %eax, %ebx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0xffe8820f; WORD $0xffff // jb LBB36_106, $-24(%rip) + +LBB36_109: + WORD $0xff48; BYTE $0xca // decq %rdx + LONG $0x65358d48; WORD $0x003b; BYTE $0x00 // leaq $15205(%rip), %rsi /* _Digits(%rip) */ + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_110: + WORD $0xd889 // movl %ebx, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi + WORD $0xd989 // movl %ebx, %ecx + WORD $0xf929 // subl %edi, %ecx + LONG $0x4e0cb70f // movzwl (%rsi,%rcx,2), %ecx + LONG $0xff4a8966 // movw %cx, $-1(%rdx) + LONG $0xfec28348 // addq $-2, %rdx + LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx + WORD $0xc389 // movl %eax, %ebx + LONG $0xffd2870f; WORD $0xffff // ja LBB36_110, $-46(%rip) + +LBB36_111: + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x0019820f; WORD $0x0000 // jb LBB36_113, $25(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0x1d0d8d48; WORD $0x003b; BYTE $0x00 // leaq $15133(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8966; BYTE $0x01 // movw %ax, (%rcx) + LONG $0x000008e9; BYTE $0x00 // jmp LBB36_114, $8(%rip) + +LBB36_113: + WORD $0x3004 // addb $48, %al + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x0188 // movb %al, (%rcx) + +LBB36_114: + WORD $0x294d; BYTE $0xf7 // subq %r14, %r15 + WORD $0x294d; BYTE $0xf0 // subq %r14, %r8 + WORD $0xff49; BYTE $0xc0 // incq %r8 + LONG $0x1e048d43 // leal (%r14,%r11), %eax + WORD $0xd8f6 // negb %al + LONG $0x33148d43 // leal (%r11,%r14), %edx + WORD $0xdaf7 // negl %edx + LONG $0x332c8d47 // leal (%r11,%r14), %r13d + WORD $0xff41; BYTE $0xcd // decl %r13d + LONG $0x33348d43 // leal (%r11,%r14), %esi + WORD $0xc683; BYTE $0xfe // addl $-2, %esi + WORD $0xc931 // xorl %ecx, %ecx + + // .p2align 4, 0x90 +LBB36_115: + WORD $0xc389 // movl %eax, %ebx + WORD $0x438d; BYTE $0x03 // leal $3(%rbx), %eax + WORD $0xc6ff // incl %esi + LONG $0x0f7c8041; WORD $0x30ff // cmpb $48, $-1(%r15,%rcx) + LONG $0xff498d48 // leaq $-1(%rcx), %rcx + LONG $0xffe9840f; WORD $0xffff // je LBB36_115, $-23(%rip) + LONG $0x0f048d49 // leaq (%r15,%rcx), %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00b28e0f; WORD $0x0000 // jle LBB36_121, $178(%rip) + WORD $0x2945; BYTE $0xf4 // subl %r14d, %r12d + LONG $0x0c3c8d41 // leal (%r12,%rcx), %edi + WORD $0xc7ff // incl %edi + WORD $0x3941; BYTE $0xfa // cmpl %edi, %r10d + LONG $0x002d8d0f; WORD $0x0000 // jge LBB36_122, $45(%rip) + WORD $0x6348; BYTE $0xc2 // movslq %edx, %rax + LONG $0x08348d48 // leaq (%rax,%rcx), %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xf685 // testl %esi, %esi + WORD $0x894d; BYTE $0xcd // movq %r9, %r13 + LONG $0x011a8e0f; WORD $0x0000 // jle LBB36_133, $282(%rip) + WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d + LONG $0xff508d49 // leaq $-1(%r8), %rdx + LONG $0x03fa8348 // cmpq $3, %rdx + LONG $0x009a830f; WORD $0x0000 // jae LBB36_127, $154(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x0000c6e9; BYTE $0x00 // jmp LBB36_130, $198(%rip) + +LBB36_122: + WORD $0x8945; BYTE $0xea // movl %r13d, %r10d + WORD $0x2949; BYTE $0xca // subq %rcx, %r10 + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00648e0f; WORD $0x0000 // jle LBB36_121, $100(%rip) + LONG $0x331c8d43 // leal (%r11,%r14), %ebx + WORD $0xc383; BYTE $0xfe // addl $-2, %ebx + WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx + WORD $0xd231 // xorl %edx, %edx + WORD $0xfb83; BYTE $0x7f // cmpl $127, %ebx + WORD $0x894d; BYTE $0xcd // movq %r9, %r13 + LONG $0x0223820f; WORD $0x0000 // jb LBB36_140, $547(%rip) + WORD $0x0145; BYTE $0xde // addl %r11d, %r14d + LONG $0xfec68341 // addl $-2, %r14d + WORD $0x2949; BYTE $0xce // subq %rcx, %r14 + WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d + WORD $0xff49; BYTE $0xc3 // incq %r11 + WORD $0x894c; BYTE $0xda // movq %r11, %rdx + LONG $0x80e28348 // andq $-128, %rdx + LONG $0xd07d8b48 // movq $-48(%rbp), %rdi + WORD $0x014c; BYTE $0xc7 // addq %r8, %rdi + WORD $0xf089 // movl %esi, %eax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x80e08348 // andq $-128, %rax + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + LONG $0x80728d48 // leaq $-128(%rdx), %rsi + WORD $0x8949; BYTE $0xf0 // movq %rsi, %r8 + LONG $0x07e8c149 // shrq $7, %r8 + WORD $0xff49; BYTE $0xc0 // incq %r8 + LONG $0x80fe8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rsi + LONG $0x00ae830f; WORD $0x0000 // jae LBB36_134, $174(%rip) + WORD $0xf631 // xorl %esi, %esi + LONG $0x000163e9; BYTE $0x00 // jmp LBB36_136, $355(%rip) + +LBB36_121: + WORD $0x894d; BYTE $0xcd // movq %r9, %r13 + LONG $0x0001e0e9; BYTE $0x00 // jmp LBB36_92, $480(%rip) + +LBB36_107: + LONG $0x0004be41; WORD $0x0000 // movl $4, %r14d + LONG $0xfc578d49 // leaq $-4(%r15), %rdx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0xfe65820f; WORD $0xffff // jb LBB36_106, $-411(%rip) + LONG $0xfffe78e9; BYTE $0xff // jmp LBB36_109, $-392(%rip) + +LBB36_127: + WORD $0xe683; BYTE $0xfc // andl $-4, %esi + WORD $0xf748; BYTE $0xde // negq %rsi + WORD $0xd231 // xorl %edx, %edx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_128: + LONG $0x173c8d49 // leaq (%r15,%rdx), %rdi + LONG $0xfd39448b // movl $-3(%rcx,%rdi), %eax + LONG $0xfe394489 // movl %eax, $-2(%rcx,%rdi) + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffe7850f; WORD $0xffff // jne LBB36_128, $-25(%rip) + WORD $0xf748; BYTE $0xda // negq %rdx + +LBB36_130: + LONG $0x03c0f641 // testb $3, %r8b + LONG $0x0032840f; WORD $0x0000 // je LBB36_133, $50(%rip) + WORD $0xb60f; BYTE $0xc3 // movzbl %bl, %eax + WORD $0xe083; BYTE $0x03 // andl $3, %eax + WORD $0xf748; BYTE $0xd8 // negq %rax + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi + WORD $0xd231 // xorl %edx, %edx + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_132: + LONG $0x163c8d48 // leaq (%rsi,%rdx), %rdi + LONG $0x391cb60f // movzbl (%rcx,%rdi), %ebx + LONG $0x01395c88 // movb %bl, $1(%rcx,%rdi) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0xffe8850f; WORD $0xffff // jne LBB36_132, $-24(%rip) + +LBB36_133: + WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + LONG $0x2e0204c6 // movb $46, (%rdx,%rax) + LONG $0x0f048d49 // leaq (%r15,%rcx), %rax + LONG $0x02c08348 // addq $2, %rax + LONG $0x000141e9; BYTE $0x00 // jmp LBB36_92, $321(%rip) + +LBB36_134: + WORD $0x8944; BYTE $0xf3 // movl %r14d, %ebx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x80e38348 // andq $-128, %rbx + LONG $0x80c38348 // addq $-128, %rbx + LONG $0x07ebc148 // shrq $7, %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfce38348 // andq $-4, %rbx + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff2ed056ffdc5 // vmovdqa $-3347(%rip), %ymm0 /* LCPI36_0(%rip) */ + +LBB36_135: + LONG $0x373c8d49 // leaq (%r15,%rsi), %rdi + LONG $0x447ffec5; WORD $0x0139 // vmovdqu %ymm0, $1(%rcx,%rdi) + LONG $0x447ffec5; WORD $0x2139 // vmovdqu %ymm0, $33(%rcx,%rdi) + LONG $0x447ffec5; WORD $0x4139 // vmovdqu %ymm0, $65(%rcx,%rdi) + LONG $0x447ffec5; WORD $0x6139 // vmovdqu %ymm0, $97(%rcx,%rdi) + QUAD $0x00008139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $129(%rcx,%rdi) + QUAD $0x0000a139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $161(%rcx,%rdi) + QUAD $0x0000c139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $193(%rcx,%rdi) + QUAD $0x0000e139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $225(%rcx,%rdi) + QUAD $0x00010139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $257(%rcx,%rdi) + QUAD $0x00012139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $289(%rcx,%rdi) + QUAD $0x00014139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $321(%rcx,%rdi) + QUAD $0x00016139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $353(%rcx,%rdi) + QUAD $0x00018139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $385(%rcx,%rdi) + QUAD $0x0001a139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $417(%rcx,%rdi) + QUAD $0x0001c139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $449(%rcx,%rdi) + QUAD $0x0001e139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $481(%rcx,%rdi) + LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq $512, %rsi + LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xff67850f; WORD $0xffff // jne LBB36_135, $-153(%rip) + +LBB36_136: + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0x03c0f641 // testb $3, %r8b + LONG $0x005a840f; WORD $0x0000 // je LBB36_139, $90(%rip) + WORD $0xff41; BYTE $0xc6 // incl %r14d + LONG $0x80e68141; WORD $0x0001; BYTE $0x00 // andl $384, %r14d + LONG $0x80c68341 // addl $-128, %r14d + LONG $0x07eec141 // shrl $7, %r14d + WORD $0xfe41; BYTE $0xc6 // incb %r14b + LONG $0xc6b60f45 // movzbl %r14b, %r8d + LONG $0x03e08341 // andl $3, %r8d + LONG $0x07e0c149 // shlq $7, %r8 + WORD $0x014c; BYTE $0xfe // addq %r15, %rsi + LONG $0x61c68348 // addq $97, %rsi + WORD $0xdb31 // xorl %ebx, %ebx + QUAD $0xfffff215056ffdc5 // vmovdqa $-3563(%rip), %ymm0 /* LCPI36_0(%rip) */ + +LBB36_138: + LONG $0x1e3c8d48 // leaq (%rsi,%rbx), %rdi + LONG $0x447ffec5; WORD $0xa039 // vmovdqu %ymm0, $-96(%rcx,%rdi) + LONG $0x447ffec5; WORD $0xc039 // vmovdqu %ymm0, $-64(%rcx,%rdi) + LONG $0x447ffec5; WORD $0xe039 // vmovdqu %ymm0, $-32(%rcx,%rdi) + LONG $0x047ffec5; BYTE $0x39 // vmovdqu %ymm0, (%rcx,%rdi) + LONG $0x80eb8348 // subq $-128, %rbx + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0xffd8850f; WORD $0xffff // jne LBB36_138, $-40(%rip) + +LBB36_139: + WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 + LONG $0x0015840f; WORD $0x0000 // je LBB36_92, $21(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB36_140: + WORD $0x00c6; BYTE $0x30 // movb $48, (%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0xc2ff // incl %edx + WORD $0x3944; BYTE $0xd2 // cmpl %r10d, %edx + LONG $0xffef8c0f; WORD $0xffff // jl LBB36_140, $-17(%rip) + +LBB36_92: + WORD $0x2944; BYTE $0xe8 // subl %r13d, %eax + +LBB36_93: + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB36_141: + WORD $0xc031 // xorl %eax, %eax + LONG $0xffffe7e9; BYTE $0xff // jmp LBB36_93, $-25(%rip) + +LBB36_142: + LONG $0xd07d8948 // movq %rdi, $-48(%rbp) + LONG $0xff6bb841; WORD $0xffff // movl $-149, %r8d + WORD $0x8941; BYTE $0xc7 // movl %eax, %r15d + LONG $0xfff257e9; BYTE $0xff // jmp LBB36_8, $-3497(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +_format_significand: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x20e8c148 // shrq $32, %rax + LONG $0x001c850f; WORD $0x0000 // jne LBB37_2, $28(%rip) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx + LONG $0x00e3830f; WORD $0x0000 // jae LBB37_8, $227(%rip) + +LBB37_7: + WORD $0xd789 // movl %edx, %edi + LONG $0x000132e9; BYTE $0x00 // jmp LBB37_10, $306(%rip) + +LBB37_2: + QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0x1f00ca69; WORD $0xfa0a // imull $-100000000, %edx, %ecx + WORD $0xf901 // addl %edi, %ecx + LONG $0x00a4840f; WORD $0x0000 // je LBB37_3, $164(%rip) + WORD $0xc889 // movl %ecx, %eax + LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d + LONG $0xc1af0f49 // imulq %r9, %rax + LONG $0x2de8c148 // shrq $45, %rax + LONG $0x2710f869; WORD $0x0000 // imull $10000, %eax, %edi + WORD $0xf929 // subl %edi, %ecx + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xf9af0f49 // imulq %r9, %rdi + LONG $0x2defc148 // shrq $45, %rdi + LONG $0x2710ff69; WORD $0x0000 // imull $10000, %edi, %edi + WORD $0xf829 // subl %edi, %eax + WORD $0xb70f; BYTE $0xf9 // movzwl %cx, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull $5243, %edi, %r9d + LONG $0x11e9c141 // shrl $17, %r9d + LONG $0x64f96b41 // imull $100, %r9d, %edi + WORD $0xf929 // subl %edi, %ecx + LONG $0xd1b70f44 // movzwl %cx, %r10d + WORD $0xb70f; BYTE $0xf8 // movzwl %ax, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x147bff69; WORD $0x0000 // imull $5243, %edi, %edi + WORD $0xefc1; BYTE $0x11 // shrl $17, %edi + WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0xd8b70f44 // movzwl %ax, %r11d + LONG $0x330d8d48; WORD $0x0037; BYTE $0x00 // leaq $14131(%rip), %rcx /* _Digits(%rip) */ + LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax + LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) + LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax + LONG $0x40894166; BYTE $0xfc // movw %ax, $-4(%r8) + LONG $0x04b70f42; BYTE $0x59 // movzwl (%rcx,%r11,2), %eax + LONG $0x40894166; BYTE $0xfa // movw %ax, $-6(%r8) + LONG $0x7904b70f // movzwl (%rcx,%rdi,2), %eax + LONG $0x40894166; BYTE $0xf8 // movw %ax, $-8(%r8) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0xf8708d4d // leaq $-8(%r8), %r14 + LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx + LONG $0xff38820f; WORD $0xffff // jb LBB37_7, $-200(%rip) + LONG $0x000016e9; BYTE $0x00 // jmp LBB37_8, $22(%rip) + +LBB37_3: + LONG $0x0008b941; WORD $0x0000 // movl $8, %r9d + LONG $0xf8708d4d // leaq $-8(%r8), %r14 + LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx + LONG $0xff1d820f; WORD $0xffff // jb LBB37_7, $-227(%rip) + +LBB37_8: + LONG $0x1759ba41; WORD $0xd1b7 // movl $3518437209, %r10d + LONG $0xd11d8d4c; WORD $0x0036; BYTE $0x00 // leaq $14033(%rip), %r11 /* _Digits(%rip) */ + BYTE $0x90 // .p2align 4, 0x90 + +LBB37_9: + WORD $0xd789 // movl %edx, %edi + LONG $0xfaaf0f49 // imulq %r10, %rdi + LONG $0x2defc148 // shrq $45, %rdi + LONG $0xd8f0c769; WORD $0xffff // imull $-10000, %edi, %eax + WORD $0xd001 // addl %edx, %eax + LONG $0x1fd86948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rbx + LONG $0x25ebc148 // shrq $37, %rbx + WORD $0xcb6b; BYTE $0x64 // imull $100, %ebx, %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0x04b70f41; BYTE $0x43 // movzwl (%r11,%rax,2), %eax + LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) + LONG $0x04b70f41; BYTE $0x5b // movzwl (%r11,%rbx,2), %eax + LONG $0x46894166; BYTE $0xfc // movw %ax, $-4(%r14) + LONG $0xfcc68349 // addq $-4, %r14 + LONG $0xe0fffa81; WORD $0x05f5 // cmpl $99999999, %edx + WORD $0xfa89 // movl %edi, %edx + LONG $0xffb8870f; WORD $0xffff // ja LBB37_9, $-72(%rip) + +LBB37_10: + WORD $0xff83; BYTE $0x64 // cmpl $100, %edi + LONG $0x0020830f; WORD $0x0000 // jae LBB37_11, $32(%rip) + WORD $0xff83; BYTE $0x0a // cmpl $10, %edi + LONG $0x004d820f; WORD $0x0000 // jb LBB37_14, $77(%rip) + +LBB37_13: + WORD $0xf889 // movl %edi, %eax + LONG $0x6d0d8d48; WORD $0x0036; BYTE $0x00 // leaq $13933(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) + LONG $0x00003de9; BYTE $0x00 // jmp LBB37_15, $61(%rip) + +LBB37_11: + WORD $0xb70f; BYTE $0xc7 // movzwl %di, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx + WORD $0xcf29 // subl %ecx, %edi + WORD $0xb70f; BYTE $0xcf // movzwl %di, %ecx + LONG $0x41158d48; WORD $0x0036; BYTE $0x00 // leaq $13889(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x4e894166; BYTE $0xfe // movw %cx, $-2(%r14) + LONG $0xfec68349 // addq $-2, %r14 + WORD $0xc789 // movl %eax, %edi + WORD $0xff83; BYTE $0x0a // cmpl $10, %edi + LONG $0xffb3830f; WORD $0xffff // jae LBB37_13, $-77(%rip) + +LBB37_14: + LONG $0x30c78040 // addb $48, %dil + WORD $0x8840; BYTE $0x3e // movb %dil, (%rsi) + +LBB37_15: + WORD $0x294d; BYTE $0xc8 // subq %r9, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_left_shift: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0xf189 // movl %esi, %ecx + LONG $0x68c16b48 // imulq $104, %rcx, %rax + LONG $0xea158d48; WORD $0x008f; BYTE $0x00 // leaq $36842(%rip), %rdx /* _LSHIFT_TAB(%rip) */ + LONG $0x10048b44 // movl (%rax,%rdx), %r8d + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0x04c28348 // addq $4, %rdx + LONG $0x10476348 // movslq $16(%rdi), %rax + WORD $0xf631 // xorl %esi, %esi + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0031840f; WORD $0x0000 // je LBB38_6, $49(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB38_1: + LONG $0x321cb60f // movzbl (%rdx,%rsi), %ebx + WORD $0xdb84 // testb %bl, %bl + LONG $0x0025840f; WORD $0x0000 // je LBB38_8, $37(%rip) + LONG $0x311c3841 // cmpb %bl, (%r9,%rsi) + LONG $0x0189850f; WORD $0x0000 // jne LBB38_3, $393(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffde850f; WORD $0xffff // jne LBB38_1, $-34(%rip) + WORD $0xc689 // movl %eax, %esi + +LBB38_6: + LONG $0x00323c80 // cmpb $0, (%rdx,%rsi) + LONG $0x0003840f; WORD $0x0000 // je LBB38_8, $3(%rip) + +LBB38_7: + WORD $0xff41; BYTE $0xc8 // decl %r8d + +LBB38_8: + WORD $0xc085 // testl %eax, %eax + LONG $0x00968e0f; WORD $0x0000 // jle LBB38_22, $150(%rip) + LONG $0x001c8d45 // leal (%r8,%rax), %r11d + WORD $0xc389 // movl %eax, %ebx + WORD $0x634d; BYTE $0xf3 // movslq %r11d, %r14 + WORD $0xff49; BYTE $0xce // decq %r14 + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xd231 // xorl %edx, %edx + QUAD $0xcccccccccccdba49; WORD $0xcccc // movabsq $-3689348814741910323, %r10 + LONG $0x000023e9; BYTE $0x00 // jmp LBB38_10, $35(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB38_11: + WORD $0x3004 // addb $48, %al + LONG $0x31048843 // movb %al, (%r9,%r14) + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + +LBB38_18: + WORD $0xff41; BYTE $0xcb // decl %r11d + WORD $0xff49; BYTE $0xce // decq %r14 + WORD $0xff48; BYTE $0xcb // decq %rbx + LONG $0x01fb8348 // cmpq $1, %rbx + LONG $0x0049860f; WORD $0x0000 // jbe LBB38_12, $73(%rip) + +LBB38_10: + WORD $0x438d; BYTE $0xfe // leal $-2(%rbx), %eax + LONG $0x34be0f49; BYTE $0x01 // movsbq (%r9,%rax), %rsi + LONG $0xd0c68348 // addq $-48, %rsi + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe2 // mulq %r10 + LONG $0x03eac148 // shrq $3, %rdx + LONG $0x12048d48 // leaq (%rdx,%rdx), %rax + LONG $0x803c8d4c // leaq (%rax,%rax,4), %r15 + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x294c; BYTE $0xf8 // subq %r15, %rax + LONG $0x0877394c // cmpq %r14, $8(%rdi) + LONG $0xffb0870f; WORD $0xffff // ja LBB38_11, $-80(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xffb0840f; WORD $0xffff // je LBB38_18, $-80(%rip) + LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) + LONG $0xffffa4e9; BYTE $0xff // jmp LBB38_18, $-92(%rip) + +LBB38_12: + LONG $0x0afe8348 // cmpq $10, %rsi + LONG $0x0070830f; WORD $0x0000 // jae LBB38_13, $112(%rip) + +LBB38_22: + LONG $0x10476348 // movslq $16(%rdi), %rax + WORD $0x6349; BYTE $0xc8 // movslq %r8d, %rcx + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) + LONG $0x08478b48 // movq $8(%rdi), %rax + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x0005870f; WORD $0x0000 // ja LBB38_24, $5(%rip) + WORD $0x4789; BYTE $0x10 // movl %eax, $16(%rdi) + WORD $0xc189 // movl %eax, %ecx + +LBB38_24: + LONG $0x14470144 // addl %r8d, $20(%rdi) + WORD $0xc985 // testl %ecx, %ecx + LONG $0x00318e0f; WORD $0x0000 // jle LBB38_28, $49(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0xc989 // movl %ecx, %ecx + BYTE $0x90 // .p2align 4, 0x90 + +LBB38_26: + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + WORD $0xd689 // movl %edx, %esi + LONG $0x30303c80 // cmpb $48, (%rax,%rsi) + LONG $0x0028850f; WORD $0x0000 // jne LBB38_30, $40(%rip) + WORD $0xc9ff // decl %ecx + WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) + LONG $0x01728d48 // leaq $1(%rdx), %rsi + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x01fe8348 // cmpq $1, %rsi + LONG $0xffda870f; WORD $0xffff // ja LBB38_26, $-38(%rip) + LONG $0x000006e9; BYTE $0x00 // jmp LBB38_29, $6(%rip) + +LBB38_28: + LONG $0x0007850f; WORD $0x0000 // jne LBB38_30, $7(%rip) + +LBB38_29: + LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) + +LBB38_30: + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB38_13: + WORD $0x6349; BYTE $0xf3 // movslq %r11d, %rsi + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x00001be9; BYTE $0x00 // jmp LBB38_14, $27(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB38_15: + WORD $0x3004 // addb $48, %al + WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx + WORD $0x0488; BYTE $0x33 // movb %al, (%rbx,%rsi) + +LBB38_21: + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x09f98348 // cmpq $9, %rcx + LONG $0xff6a860f; WORD $0xffff // jbe LBB38_22, $-150(%rip) + +LBB38_14: + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0xf749; BYTE $0xe2 // mulq %r10 + LONG $0x03eac148 // shrq $3, %rdx + LONG $0x12048d48 // leaq (%rdx,%rdx), %rax + LONG $0x801c8d48 // leaq (%rax,%rax,4), %rbx + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax + LONG $0x08773948 // cmpq %rsi, $8(%rdi) + LONG $0xffc6870f; WORD $0xffff // ja LBB38_15, $-58(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xffc5840f; WORD $0xffff // je LBB38_21, $-59(%rip) + LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) + LONG $0xffffb9e9; BYTE $0xff // jmp LBB38_21, $-71(%rip) + +LBB38_3: + LONG $0xfe898c0f; WORD $0xffff // jl LBB38_7, $-375(%rip) + LONG $0xfffe87e9; BYTE $0xff // jmp LBB38_8, $-377(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_right_shift: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + WORD $0xf189 // movl %esi, %ecx + LONG $0x10478b44 // movl $16(%rdi), %r8d + WORD $0xd231 // xorl %edx, %edx + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0x0000bb41; WORD $0x0000 // movl $0, %r11d + LONG $0xd84f0f45 // cmovgl %r8d, %r11d + WORD $0xc031 // xorl %eax, %eax + LONG $0x90909090 // .p2align 4, 0x90 + +LBB39_1: + WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 + LONG $0x0132840f; WORD $0x0000 // je LBB39_2, $306(%rip) + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + LONG $0x34be0f48; BYTE $0x16 // movsbq (%rsi,%rdx), %rsi + LONG $0x46048d48 // leaq (%rsi,%rax,2), %rax + LONG $0xd0c08348 // addq $-48, %rax + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0xd348; BYTE $0xee // shrq %cl, %rsi + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xffd1840f; WORD $0xffff // je LBB39_1, $-47(%rip) + WORD $0x8941; BYTE $0xd3 // movl %edx, %r11d + +LBB39_7: + WORD $0x578b; BYTE $0x14 // movl $20(%rdi), %edx + WORD $0x2944; BYTE $0xda // subl %r11d, %edx + WORD $0xc2ff // incl %edx + LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 + WORD $0xd349; BYTE $0xe1 // shlq %cl, %r9 + WORD $0x5789; BYTE $0x14 // movl %edx, $20(%rdi) + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3945; BYTE $0xc3 // cmpl %r8d, %r11d + LONG $0x00718d0f; WORD $0x0000 // jge LBB39_10, $113(%rip) + WORD $0x634d; BYTE $0xc3 // movslq %r11d, %r8 + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + BYTE $0x90 // .p2align 4, 0x90 + +LBB39_9: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x214c; BYTE $0xc8 // andq %r9, %rax + WORD $0xc280; BYTE $0x30 // addb $48, %dl + LONG $0x16148842 // movb %dl, (%rsi,%r10) + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + LONG $0x06148d4a // leaq (%rsi,%r8), %rdx + LONG $0x1cbe0f4d; BYTE $0x12 // movsbq (%r10,%rdx), %r11 + LONG $0x105c8d4b; BYTE $0x01 // leaq $1(%r8,%r10), %rbx + WORD $0xff49; BYTE $0xc2 // incq %r10 + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + LONG $0x43048d49 // leaq (%r11,%rax,2), %rax + LONG $0xd0c08348 // addq $-48, %rax + LONG $0x10576348 // movslq $16(%rdi), %rdx + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0xffc38c0f; WORD $0xffff // jl LBB39_9, $-61(%rip) + LONG $0x000025e9; BYTE $0x00 // jmp LBB39_10, $37(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB39_12: + LONG $0x30c68040 // addb $48, %sil + WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx + LONG $0x13348840 // movb %sil, (%rbx,%rdx) + WORD $0xc2ff // incl %edx + WORD $0x8941; BYTE $0xd2 // movl %edx, %r10d + +LBB39_15: + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + +LBB39_10: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x002b840f; WORD $0x0000 // je LBB39_16, $43(%rip) + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0xd348; BYTE $0xee // shrq %cl, %rsi + WORD $0x214c; BYTE $0xc8 // andq %r9, %rax + WORD $0x6349; BYTE $0xd2 // movslq %r10d, %rdx + LONG $0x08573948 // cmpq %rdx, $8(%rdi) + LONG $0xffca870f; WORD $0xffff // ja LBB39_12, $-54(%rip) + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xffd1840f; WORD $0xffff // je LBB39_15, $-47(%rip) + LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) + LONG $0xffffc5e9; BYTE $0xff // jmp LBB39_15, $-59(%rip) + +LBB39_16: + LONG $0x10578944 // movl %r10d, $16(%rdi) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00758e0f; WORD $0x0000 // jle LBB39_20, $117(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0x9090 // .p2align 4, 0x90 + +LBB39_18: + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + WORD $0xd689 // movl %edx, %esi + LONG $0x30303c80 // cmpb $48, (%rax,%rsi) + LONG $0x0063850f; WORD $0x0000 // jne LBB39_22, $99(%rip) + WORD $0xc9ff // decl %ecx + WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) + LONG $0x01728d48 // leaq $1(%rdx), %rsi + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x01fe8348 // cmpq $1, %rsi + LONG $0xffda870f; WORD $0xffff // ja LBB39_18, $-38(%rip) + LONG $0x00004be9; BYTE $0x00 // jmp LBB39_21, $75(%rip) + +LBB39_2: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x004c840f; WORD $0x0000 // je LBB39_23, $76(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xfed3850f; WORD $0xffff // jne LBB39_7, $-301(%rip) + +LBB39_4: + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + WORD $0xff41; BYTE $0xc3 // incl %r11d + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffe7840f; WORD $0xffff // je LBB39_4, $-25(%rip) + LONG $0xfffeb5e9; BYTE $0xff // jmp LBB39_7, $-331(%rip) + +LBB39_20: + LONG $0x0003840f; WORD $0x0000 // je LBB39_21, $3(%rip) + +LBB39_22: + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB39_21: + LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB39_23: + LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl $0, $16(%rdi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI40_0: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI40_1: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + + // .p2align 4, 0x90 +_advance_string_default: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + LONG $0x087f8b4c // movq $8(%rdi), %r15 + WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 + LONG $0x0364840f; WORD $0x0000 // je LBB40_17, $868(%rip) + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + LONG $0x40ff8349 // cmpq $64, %r15 + LONG $0x01de820f; WORD $0x0000 // jb LBB40_18, $478(%rip) + WORD $0x8948; BYTE $0xf7 // movq %rsi, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + QUAD $0xffffff98056ff9c5 // vmovdqa $-104(%rip), %xmm0 /* LCPI40_0(%rip) */ + QUAD $0xffffffa00d6ff9c5 // vmovdqa $-96(%rip), %xmm1 /* LCPI40_1(%rip) */ + + // .p2align 4, 0x90 +LBB40_3: + LONG $0x6f7ac1c4; WORD $0x3114 // vmovdqu (%r9,%rsi), %xmm2 + LONG $0x6f7ac1c4; WORD $0x315c; BYTE $0x10 // vmovdqu $16(%r9,%rsi), %xmm3 + LONG $0x6f7ac1c4; WORD $0x3164; BYTE $0x20 // vmovdqu $32(%r9,%rsi), %xmm4 + LONG $0x6f7ac1c4; WORD $0x316c; BYTE $0x30 // vmovdqu $48(%r9,%rsi), %xmm5 + LONG $0xf074e9c5 // vpcmpeqb %xmm0, %xmm2, %xmm6 + LONG $0xe6d779c5 // vpmovmskb %xmm6, %r12d + LONG $0xf074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm6 + LONG $0xc6d7f9c5 // vpmovmskb %xmm6, %eax + LONG $0xf074d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm6 + LONG $0xc6d779c5 // vpmovmskb %xmm6, %r8d + LONG $0xf074d1c5 // vpcmpeqb %xmm0, %xmm5, %xmm6 + LONG $0xd6d779c5 // vpmovmskb %xmm6, %r10d + LONG $0xd174e9c5 // vpcmpeqb %xmm1, %xmm2, %xmm2 + LONG $0xead779c5 // vpmovmskb %xmm2, %r13d + LONG $0xd174e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm2 + LONG $0xcad7f9c5 // vpmovmskb %xmm2, %ecx + LONG $0xd174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm2 + LONG $0xdad7f9c5 // vpmovmskb %xmm2, %ebx + LONG $0xd174d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm2 + LONG $0xdad779c5 // vpmovmskb %xmm2, %r11d + LONG $0x30e2c149 // shlq $48, %r10 + LONG $0x20e0c149 // shlq $32, %r8 + WORD $0x094d; BYTE $0xd0 // orq %r10, %r8 + LONG $0x10e0c148 // shlq $16, %rax + WORD $0x094c; BYTE $0xc0 // orq %r8, %rax + WORD $0x0949; BYTE $0xc4 // orq %rax, %r12 + LONG $0x30e3c149 // shlq $48, %r11 + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x094c; BYTE $0xdb // orq %r11, %rbx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xd9 // orq %rbx, %rcx + WORD $0x0949; BYTE $0xcd // orq %rcx, %r13 + LONG $0x0030850f; WORD $0x0000 // jne LBB40_7, $48(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0040850f; WORD $0x0000 // jne LBB40_9, $64(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0086850f; WORD $0x0000 // jne LBB40_10, $134(%rip) + +LBB40_6: + LONG $0xc0c78349 // addq $-64, %r15 + LONG $0xc0c78348 // addq $-64, %rdi + LONG $0x40c68348 // addq $64, %rsi + LONG $0x3fff8349 // cmpq $63, %r15 + LONG $0xff4a870f; WORD $0xffff // ja LBB40_3, $-182(%rip) + LONG $0x000081e9; BYTE $0x00 // jmp LBB40_12, $129(%rip) + +LBB40_7: + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x000e850f; WORD $0x0000 // jne LBB40_9, $14(%rip) + LONG $0xc5bc0f49 // bsfq %r13, %rax + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0xd0458948 // movq %rax, $-48(%rbp) + WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) + +LBB40_9: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x214c; BYTE $0xe8 // andq %r13, %rax + LONG $0x00048d4c // leaq (%rax,%rax), %r8 + WORD $0x094d; BYTE $0xf0 // orq %r14, %r8 + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx + WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + LONG $0xc6920f41 // setb %r14b + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + QUAD $0x555555555555b848; WORD $0x5555 // movabsq $6148914691236517205, %rax + WORD $0x3148; BYTE $0xc1 // xorq %rax, %rcx + WORD $0x214c; BYTE $0xc1 // andq %r8, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x2149; BYTE $0xcc // andq %rcx, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0xff7a840f; WORD $0xffff // je LBB40_6, $-134(%rip) + +LBB40_10: + LONG $0xc4bc0f49 // bsfq %r12, %rax + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + +LBB40_11: + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB40_12: + WORD $0x014c; BYTE $0xce // addq %r9, %rsi + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x00f1820f; WORD $0x0000 // jb LBB40_23, $241(%rip) + +LBB40_13: + LONG $0x066ffac5 // vmovdqu (%rsi), %xmm0 + LONG $0x4e6ffac5; BYTE $0x10 // vmovdqu $16(%rsi), %xmm1 + QUAD $0xfffffe36156ff9c5 // vmovdqa $-458(%rip), %xmm2 /* LCPI40_0(%rip) */ + QUAD $0xfffffe3e1d6ff9c5 // vmovdqa $-450(%rip), %xmm3 /* LCPI40_1(%rip) */ + LONG $0xe274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm4 + LONG $0xfcd7f9c5 // vpmovmskb %xmm4, %edi + LONG $0xd274f1c5 // vpcmpeqb %xmm2, %xmm1, %xmm2 + LONG $0xcad7f9c5 // vpmovmskb %xmm2, %ecx + LONG $0xc374f9c5 // vpcmpeqb %xmm3, %xmm0, %xmm0 + LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax + LONG $0xc374f1c5 // vpcmpeqb %xmm3, %xmm1, %xmm0 + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi + LONG $0x10e3c148 // shlq $16, %rbx + WORD $0x0948; BYTE $0xd8 // orq %rbx, %rax + LONG $0x0044850f; WORD $0x0000 // jne LBB40_19, $68(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x005a850f; WORD $0x0000 // jne LBB40_21, $90(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0087840f; WORD $0x0000 // je LBB40_22, $135(%rip) + +LBB40_16: + LONG $0xc7bc0f48 // bsfq %rdi, %rax + WORD $0x294c; BYTE $0xce // subq %r9, %rsi + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xffff70e9; BYTE $0xff // jmp LBB40_11, $-144(%rip) + +LBB40_18: + WORD $0x014c; BYTE $0xce // addq %r9, %rsi + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0xff74830f; WORD $0xffff // jae LBB40_13, $-140(%rip) + LONG $0x000060e9; BYTE $0x00 // jmp LBB40_23, $96(%rip) + +LBB40_19: + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0014850f; WORD $0x0000 // jne LBB40_21, $20(%rip) + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + WORD $0x294c; BYTE $0xc9 // subq %r9, %rcx + LONG $0xd8bc0f48 // bsfq %rax, %rbx + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) + +LBB40_21: + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xc121 // andl %eax, %ecx + WORD $0x1c8d; BYTE $0x09 // leal (%rcx,%rcx), %ebx + LONG $0x4e048d45 // leal (%r14,%rcx,2), %r8d + WORD $0xd3f7 // notl %ebx + WORD $0xc321 // andl %eax, %ebx + LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0xcb01 // addl %ecx, %ebx + LONG $0xc6920f41 // setb %r14b + WORD $0xdb01 // addl %ebx, %ebx + LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx + WORD $0x2144; BYTE $0xc3 // andl %r8d, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xdf21 // andl %ebx, %edi + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xff79850f; WORD $0xffff // jne LBB40_16, $-135(%rip) + +LBB40_22: + LONG $0x20c68348 // addq $32, %rsi + LONG $0xe0c78349 // addq $-32, %r15 + +LBB40_23: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x00b4850f; WORD $0x0000 // jne LBB40_38, $180(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0088840f; WORD $0x0000 // je LBB40_35, $136(%rip) + +LBB40_25: + WORD $0x894c; BYTE $0xcf // movq %r9, %rdi + WORD $0xf748; BYTE $0xdf // negq %rdi + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + +LBB40_26: + WORD $0xdb31 // xorl %ebx, %ebx + +LBB40_27: + LONG $0x1e0cb60f // movzbl (%rsi,%rbx), %ecx + WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx + LONG $0x0066840f; WORD $0x0000 // je LBB40_34, $102(%rip) + WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx + LONG $0x0011840f; WORD $0x0000 // je LBB40_30, $17(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 + LONG $0xffde850f; WORD $0xffff // jne LBB40_27, $-34(%rip) + LONG $0x00005de9; BYTE $0x00 // jmp LBB40_36, $93(%rip) + +LBB40_30: + LONG $0xff4f8d49 // leaq $-1(%r15), %rcx + WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx + LONG $0xfe9e840f; WORD $0xffff // je LBB40_11, $-354(%rip) + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x000e850f; WORD $0x0000 // jne LBB40_33, $14(%rip) + LONG $0x370c8d48 // leaq (%rdi,%rsi), %rcx + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + +LBB40_33: + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + LONG $0x02c68348 // addq $2, %rsi + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx + LONG $0xfec18348 // addq $-2, %rcx + LONG $0xfec78349 // addq $-2, %r15 + WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + LONG $0xff90850f; WORD $0xffff // jne LBB40_26, $-112(%rip) + LONG $0xfffe5fe9; BYTE $0xff // jmp LBB40_11, $-417(%rip) + +LBB40_34: + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + +LBB40_35: + WORD $0x294c; BYTE $0xce // subq %r9, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0xfffe4ee9; BYTE $0xff // jmp LBB40_11, $-434(%rip) + +LBB40_36: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0xfe3e850f; WORD $0xffff // jne LBB40_11, $-450(%rip) + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + LONG $0xffffdde9; BYTE $0xff // jmp LBB40_35, $-35(%rip) + +LBB40_38: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x002f840f; WORD $0x0000 // je LBB40_17, $47(%rip) + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0010850f; WORD $0x0000 // jne LBB40_41, $16(%rip) + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0xd0458948 // movq %rax, $-48(%rbp) + WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) + +LBB40_41: + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff49; BYTE $0xcf // decq %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xff22850f; WORD $0xffff // jne LBB40_25, $-222(%rip) + LONG $0xffffa5e9; BYTE $0xff // jmp LBB40_35, $-91(%rip) + +LBB40_17: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffdf2e9; BYTE $0xff // jmp LBB40_11, $-526(%rip) + LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI41_0: + BYTE $0xf0 // .byte 240 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + + // .p2align 4, 0x90 +_unescape: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x18ec8348 // subq $24, %rsp + WORD $0x8b4c; BYTE $0x2f // movq (%rdi), %r13 + WORD $0x294c; BYTE $0xee // subq %r13, %rsi + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x00d38e0f; WORD $0x0000 // jle LBB41_13, $211(%rip) + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0x01458d49 // leaq $1(%r13), %rax + LONG $0x4db60f41; BYTE $0x01 // movzbl $1(%r13), %ecx + LONG $0x53158d48; WORD $0x0077; BYTE $0x00 // leaq $30547(%rip), %rdx /* __UnquoteTab(%rip) */ + LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx + LONG $0x00fff981; WORD $0x0000 // cmpl $255, %ecx + LONG $0x0017840f; WORD $0x0000 // je LBB41_4, $23(%rip) + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0021850f; WORD $0x0000 // jne LBB41_6, $33(%rip) + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xfdc3c748; WORD $0xffff; BYTE $0xff // movq $-3, %rbx + LONG $0x000096e9; BYTE $0x00 // jmp LBB41_13, $150(%rip) + +LBB41_4: + LONG $0x03fe8348 // cmpq $3, %rsi + LONG $0x0019870f; WORD $0x0000 // ja LBB41_7, $25(%rip) + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0x000084e9; BYTE $0x00 // jmp LBB41_13, $132(%rip) + +LBB41_6: + WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) + LONG $0x02078349 // addq $2, (%r15) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0x000073e9; BYTE $0x00 // jmp LBB41_13, $115(%rip) + +LBB41_7: + LONG $0x024d8b41 // movl $2(%r13), %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xd0f7 // notl %eax + LONG $0xcfd0918d; WORD $0xcfcf // leal $-808464432(%rcx), %edx + LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax + WORD $0xd085 // testl %edx, %eax + LONG $0x004a850f; WORD $0x0000 // jne LBB41_11, $74(%rip) + LONG $0x1919918d; WORD $0x1919 // leal $421075225(%rcx), %edx + WORD $0xca09 // orl %ecx, %edx + LONG $0x8080c2f7; WORD $0x8080 // testl $-2139062144, %edx + LONG $0x0036850f; WORD $0x0000 // jne LBB41_11, $54(%rip) + WORD $0xca89 // movl %ecx, %edx + LONG $0x7f7fe281; WORD $0x7f7f // andl $2139062143, %edx + LONG $0xc0c0c0bf; BYTE $0xc0 // movl $-1061109568, %edi + WORD $0xd729 // subl %edx, %edi + LONG $0x46469a8d; WORD $0x4646 // leal $1179010630(%rdx), %ebx + WORD $0xc721 // andl %eax, %edi + WORD $0xdf85 // testl %ebx, %edi + LONG $0x0017850f; WORD $0x0000 // jne LBB41_11, $23(%rip) + LONG $0xe0e0e0bf; BYTE $0xe0 // movl $-522133280, %edi + WORD $0xd729 // subl %edx, %edi + LONG $0x3939c281; WORD $0x3939 // addl $960051513, %edx + WORD $0xf821 // andl %edi, %eax + WORD $0xd085 // testl %edx, %eax + LONG $0x0020840f; WORD $0x0000 // je LBB41_14, $32(%rip) + +LBB41_11: + LONG $0x02c58349 // addq $2, %r13 + WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) + +LBB41_12: + LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx + +LBB41_13: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0x18c48348 // addq $24, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB41_14: + WORD $0xc90f // bswapl %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx + WORD $0xc101 // addl %eax, %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xc809 // orl %ecx, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx + LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx + LONG $0xe0b60f44 // movzbl %al, %r12d + WORD $0x0941; BYTE $0xcc // orl %ecx, %r12d + LONG $0x06558d49 // leaq $6(%r13), %rdx + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + LONG $0x7ffc8341 // cmpl $127, %r12d + LONG $0x004c860f; WORD $0x0000 // jbe LBB41_18, $76(%rip) + LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d + LONG $0x004c860f; WORD $0x0000 // jbe LBB41_19, $76(%rip) + QUAD $0xffff200024bc8d41 // leal $-57344(%r12), %edi + LONG $0xf7ffff81; WORD $0xffff // cmpl $-2049, %edi + LONG $0x0055870f; WORD $0x0000 // ja LBB41_20, $85(%rip) + WORD $0xe9c1; BYTE $0x0c // shrl $12, %ecx + WORD $0xc980; BYTE $0xe0 // orb $-32, %cl + WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) + LONG $0x06ecc141 // shrl $6, %r12d + LONG $0x3fe48041 // andb $63, %r12b + LONG $0x80cc8041 // orb $-128, %r12b + LONG $0x01668845 // movb %r12b, $1(%r14) + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x02468841 // movb %al, $2(%r14) + LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx + LONG $0xffff5fe9; BYTE $0xff // jmp LBB41_13, $-161(%rip) + +LBB41_18: + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0xffff52e9; BYTE $0xff // jmp LBB41_13, $-174(%rip) + +LBB41_19: + LONG $0x06ecc141 // shrl $6, %r12d + LONG $0xc0cc8041 // orb $-64, %r12b + WORD $0x8845; BYTE $0x26 // movb %r12b, (%r14) + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x01468841 // movb %al, $1(%r14) + LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx + LONG $0xffff35e9; BYTE $0xff // jmp LBB41_13, $-203(%rip) + +LBB41_20: + LONG $0xfcc3c748; WORD $0xffff; BYTE $0xff // movq $-4, %rbx + LONG $0x06fe8348 // cmpq $6, %rsi + LONG $0xff24820f; WORD $0xffff // jb LBB41_13, $-220(%rip) + LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d + LONG $0xff17870f; WORD $0xffff // ja LBB41_13, $-233(%rip) + WORD $0x3a80; BYTE $0x5c // cmpb $92, (%rdx) + LONG $0xff0e850f; WORD $0xffff // jne LBB41_13, $-242(%rip) + LONG $0x077d8041; BYTE $0x75 // cmpb $117, $7(%r13) + LONG $0xff03850f; WORD $0xffff // jne LBB41_13, $-253(%rip) + LONG $0x08458d49 // leaq $8(%r13), %rax + LONG $0xc8458948 // movq %rax, $-56(%rbp) + LONG $0x087d8b41 // movl $8(%r13), %edi + WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) + LONG $0xff9875e8; BYTE $0xff // callq _unhex16_is, $-26507(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x004f840f; WORD $0x0000 // je LBB41_27, $79(%rip) + WORD $0x4d8b; BYTE $0xd4 // movl $-44(%rbp), %ecx + WORD $0xc90f // bswapl %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx + WORD $0xc101 // addl %eax, %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xc809 // orl %ecx, %eax + WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx + WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax + LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax + WORD $0x148d; BYTE $0x08 // leal (%rax,%rcx), %edx + LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx + LONG $0xfbfffa81; WORD $0xffff // cmpl $-1025, %edx + LONG $0x0018870f; WORD $0x0000 // ja LBB41_28, $24(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xfffe98e9; BYTE $0xff // jmp LBB41_13, $-360(%rip) + +LBB41_27: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xfffe85e9; BYTE $0xff // jmp LBB41_12, $-379(%rip) + +LBB41_28: + WORD $0xc809 // orl %ecx, %eax + LONG $0x0ae4c141 // shll $10, %r12d + WORD $0xc189 // movl %eax, %ecx + WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx + WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax + LONG $0xa0240005; BYTE $0xfc // addl $-56613888, %eax + WORD $0xc289 // movl %eax, %edx + WORD $0xeac1; BYTE $0x12 // shrl $18, %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xeec1; BYTE $0x0c // shrl $12, %esi + LONG $0x3fe68040 // andb $63, %sil + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0x3f24 // andb $63, %al + WORD $0xe180; BYTE $0x3f // andb $63, %cl + LONG $0xc26ef9c5 // vmovd %edx, %xmm0 + LONG $0xd6b60f40 // movzbl %sil, %edx + LONG $0x2079e3c4; WORD $0x01c2 // vpinsrb $1, %edx, %xmm0, %xmm0 + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + LONG $0x2079e3c4; WORD $0x02c0 // vpinsrb $2, %eax, %xmm0, %xmm0 + WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax + LONG $0x2079e3c4; WORD $0x03c0 // vpinsrb $3, %eax, %xmm0, %xmm0 + QUAD $0xfffffd3105ebf9c5 // vpor $-719(%rip), %xmm0, %xmm0 /* LCPI41_0(%rip) */ + LONG $0x7e79c1c4; BYTE $0x06 // vmovd %xmm0, (%r14) + LONG $0x0cc58349 // addq $12, %r13 + WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) + LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx + LONG $0xfffe25e9; BYTE $0xff // jmp LBB41_13, $-475(%rip) + QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 + +_POW10_M128_TAB: + QUAD $0x1732c869cd60e453 // .quad 1671618768450675795 + QUAD $0xfa8fd5a0081c0288 // .quad -391859759250406776 + QUAD $0x0e7fbd42205c8eb4 // .quad 1044761730281672372 + QUAD $0x9c99e58405118195 // .quad -7162441377172586091 + QUAD $0x521fac92a873b261 // .quad 5917638181279478369 + QUAD $0xc3c05ee50655e1fa // .quad -4341365703038344710 + QUAD $0xe6a797b752909ef9 // .quad -1826324310255427847 + QUAD $0xf4b0769e47eb5a78 // .quad -815021110370542984 + QUAD $0x9028bed2939a635c // .quad -8058981721550724260 + QUAD $0x98ee4a22ecf3188b // .quad -7426917221622671221 + QUAD $0x7432ee873880fc33 // .quad 8373016921771146291 + QUAD $0xbf29dcaba82fdeae // .quad -4671960508600951122 + QUAD $0x113faa2906a13b3f // .quad 1242899115359157055 + QUAD $0xeef453d6923bd65a // .quad -1228264617323800998 + QUAD $0x4ac7ca59a424c507 // .quad 5388497965526861063 + QUAD $0x9558b4661b6565f8 // .quad -7685194413468457480 + QUAD $0x5d79bcf00d2df649 // .quad 6735622456908576329 + QUAD $0xbaaee17fa23ebf76 // .quad -4994806998408183946 + QUAD $0xf4d82c2c107973dc // .quad -803843965719055396 + QUAD $0xe95a99df8ace6f53 // .quad -1631822729582842029 + QUAD $0x79071b9b8a4be869 // .quad 8720969558280366185 + QUAD $0x91d8a02bb6c10594 // .quad -7937418233630358124 + QUAD $0x9748e2826cdee284 // .quad -7545532125859093884 + QUAD $0xb64ec836a47146f9 // .quad -5310086773610559751 + QUAD $0xfd1b1b2308169b25 // .quad -208543120469091547 + QUAD $0xe3e27a444d8d98b7 // .quad -2025922448585811785 + QUAD $0xfe30f0f5e50e20f7 // .quad -130339450293182217 + QUAD $0x8e6d8c6ab0787f72 // .quad -8183730558007214222 + QUAD $0xbdbd2d335e51a935 // .quad -4774610331293865675 + QUAD $0xb208ef855c969f4f // .quad -5617977179081629873 + QUAD $0xad2c788035e61382 // .quad -5968262914117332094 + QUAD $0xde8b2b66b3bc4723 // .quad -2410785455424649437 + QUAD $0x4c3bcb5021afcc31 // .quad 5493207715531443249 + QUAD $0x8b16fb203055ac76 // .quad -8424269937281487754 + QUAD $0xdf4abe242a1bbf3d // .quad -2356862392440471747 + QUAD $0xaddcb9e83c6b1793 // .quad -5918651403174471789 + QUAD $0xd71d6dad34a2af0d // .quad -2946077990550589683 + QUAD $0xd953e8624b85dd78 // .quad -2786628235540701832 + QUAD $0x8672648c40e5ad68 // .quad -8758827771735200408 + QUAD $0x87d4713d6f33aa6b // .quad -8659171674854020501 + QUAD $0x680efdaf511f18c2 // .quad 7498209359040551106 + QUAD $0xa9c98d8ccb009506 // .quad -6212278575140137722 + QUAD $0x0212bd1b2566def2 // .quad 149389661945913074 + QUAD $0xd43bf0effdc0ba48 // .quad -3153662200497784248 + QUAD $0x014bb630f7604b57 // .quad 93368538716195671 + QUAD $0x84a57695fe98746d // .quad -8888567902952197011 + QUAD $0x419ea3bd35385e2d // .quad 4728396691822632493 + QUAD $0xa5ced43b7e3e9188 // .quad -6499023860262858360 + QUAD $0x52064cac828675b9 // .quad 5910495864778290617 + QUAD $0xcf42894a5dce35ea // .quad -3512093806901185046 + QUAD $0x7343efebd1940993 // .quad 8305745933913819539 + QUAD $0x818995ce7aa0e1b2 // .quad -9112587656954322510 + QUAD $0x1014ebe6c5f90bf8 // .quad 1158810380537498616 + QUAD $0xa1ebfb4219491a1f // .quad -6779048552765515233 + QUAD $0xd41a26e077774ef6 // .quad -3163173042755514634 + QUAD $0xca66fa129f9b60a6 // .quad -3862124672529506138 + QUAD $0x8920b098955522b4 // .quad -8565652321871781196 + QUAD $0xfd00b897478238d0 // .quad -215969822234494768 + QUAD $0x55b46e5f5d5535b0 // .quad 6175682344898606512 + QUAD $0x9e20735e8cb16382 // .quad -7052510166537641086 + QUAD $0xeb2189f734aa831d // .quad -1503769105731517667 + QUAD $0xc5a890362fddbc62 // .quad -4203951689744663454 + QUAD $0xa5e9ec7501d523e4 // .quad -6491397400591784988 + QUAD $0xf712b443bbd52b7b // .quad -643253593753441413 + QUAD $0x47b233c92125366e // .quad 5166248661484910190 + QUAD $0x9a6bb0aa55653b2d // .quad -7319562523736982739 + QUAD $0x999ec0bb696e840a // .quad -7377247228426025974 + QUAD $0xc1069cd4eabe89f8 // .quad -4537767136243840520 + QUAD $0xc00670ea43ca250d // .quad -4609873017105144563 + QUAD $0xf148440a256e2c76 // .quad -1060522901877412746 + QUAD $0x380406926a5e5728 // .quad 4036358391950366504 + QUAD $0x96cd2a865764dbca // .quad -7580355841314464822 + QUAD $0xc605083704f5ecf2 // .quad -4177924046916817678 + QUAD $0xbc807527ed3e12bc // .quad -4863758783215693124 + QUAD $0xf7864a44c633682e // .quad -610719040218634194 + QUAD $0xeba09271e88d976b // .quad -1468012460592228501 + QUAD $0x7ab3ee6afbe0211d // .quad 8841672636718129437 + QUAD $0x93445b8731587ea3 // .quad -7835036815511224669 + QUAD $0x5960ea05bad82964 // .quad 6440404777470273892 + QUAD $0xb8157268fdae9e4c // .quad -5182110000961642932 + QUAD $0x6fb92487298e33bd // .quad 8050505971837842365 + QUAD $0xe61acf033d1a45df // .quad -1865951482774665761 + QUAD $0xa5d3b6d479f8e056 // .quad -6497648813669818282 + QUAD $0x8fd0c16206306bab // .quad -8083748704375247957 + QUAD $0x8f48a4899877186c // .quad -8122061017087272852 + QUAD $0xb3c4f1ba87bc8696 // .quad -5492999862041672042 + QUAD $0x331acdabfe94de87 // .quad 3682481783923072647 + QUAD $0xe0b62e2929aba83c // .quad -2254563809124702148 + QUAD $0x9ff0c08b7f1d0b14 // .quad -6921820921902855404 + QUAD $0x8c71dcd9ba0b4925 // .quad -8326631408344020699 + QUAD $0x07ecf0ae5ee44dd9 // .quad 571095884476206553 + QUAD $0xaf8e5410288e1b6f // .quad -5796603242002637969 + QUAD $0xc9e82cd9f69d6150 // .quad -3897816162832129712 + QUAD $0xdb71e91432b1a24a // .quad -2634068034075909558 + QUAD $0xbe311c083a225cd2 // .quad -4741978110983775022 + QUAD $0x892731ac9faf056e // .quad -8563821548938525330 + QUAD $0x6dbd630a48aaf406 // .quad 7907585416552444934 + QUAD $0xab70fe17c79ac6ca // .quad -6093090917745768758 + QUAD $0x092cbbccdad5b108 // .quad 661109733835780360 + QUAD $0xd64d3d9db981787d // .quad -3004677628754823043 + QUAD $0x25bbf56008c58ea5 // .quad 2719036592861056677 + QUAD $0x85f0468293f0eb4e // .quad -8795452545612846258 + QUAD $0xaf2af2b80af6f24e // .quad -5824576295778454962 + QUAD $0xa76c582338ed2621 // .quad -6382629663588669919 + QUAD $0x1af5af660db4aee1 // .quad 1942651667131707105 + QUAD $0xd1476e2c07286faa // .quad -3366601061058449494 + QUAD $0x50d98d9fc890ed4d // .quad 5825843310384704845 + QUAD $0x82cca4db847945ca // .quad -9021654690802612790 + QUAD $0xe50ff107bab528a0 // .quad -1941067898873894752 + QUAD $0xa37fce126597973c // .quad -6665382345075878084 + QUAD $0x1e53ed49a96272c8 // .quad 2185351144835019464 + QUAD $0xcc5fc196fefd7d0c // .quad -3720041912917459700 + QUAD $0x25e8e89c13bb0f7a // .quad 2731688931043774330 + QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721 + QUAD $0x77b191618c54e9ac // .quad 8624834609543440812 + QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807 + QUAD $0xd59df5b9ef6a2417 // .quad -3054014793352862697 + QUAD $0xc795830d75038c1d // .quad -4065198994811024355 + QUAD $0x4b0573286b44ad1d // .quad 5405853545163697437 + QUAD $0xf97ae3d0d2446f25 // .quad -469812725086392539 + QUAD $0x4ee367f9430aec32 // .quad 5684501474941004850 + QUAD $0x9becce62836ac577 // .quad -7211161980820077193 + QUAD $0x229c41f793cda73f // .quad 2493940825248868159 + QUAD $0xc2e801fb244576d5 // .quad -4402266457597708587 + QUAD $0x6b43527578c1110f // .quad 7729112049988473103 + QUAD $0xf3a20279ed56d48a // .quad -891147053569747830 + QUAD $0x830a13896b78aaa9 // .quad -9004363024039368023 + QUAD $0x9845418c345644d6 // .quad -7474495936122174250 + QUAD $0x23cc986bc656d553 // .quad 2579604275232953683 + QUAD $0xbe5691ef416bd60c // .quad -4731433901725329908 + QUAD $0x2cbfbe86b7ec8aa8 // .quad 3224505344041192104 + QUAD $0xedec366b11c6cb8f // .quad -1302606358729274481 + QUAD $0x7bf7d71432f3d6a9 // .quad 8932844867666826921 + QUAD $0x94b3a202eb1c3f39 // .quad -7731658001846878407 + QUAD $0xdaf5ccd93fb0cc53 // .quad -2669001970698630061 + QUAD $0xb9e08a83a5e34f07 // .quad -5052886483881210105 + QUAD $0xd1b3400f8f9cff68 // .quad -3336252463373287576 + QUAD $0xe858ad248f5c22c9 // .quad -1704422086424124727 + QUAD $0x23100809b9c21fa1 // .quad 2526528228819083169 + QUAD $0x91376c36d99995be // .quad -7982792831656159810 + QUAD $0xabd40a0c2832a78a // .quad -6065211750830921846 + QUAD $0xb58547448ffffb2d // .quad -5366805021142811859 + QUAD $0x16c90c8f323f516c // .quad 1641857348316123500 + QUAD $0xe2e69915b3fff9f9 // .quad -2096820258001126919 + QUAD $0xae3da7d97f6792e3 // .quad -5891368184943504669 + QUAD $0x8dd01fad907ffc3b // .quad -8228041688891786181 + QUAD $0x99cd11cfdf41779c // .quad -7364210231179380836 + QUAD $0xb1442798f49ffb4a // .quad -5673366092687344822 + QUAD $0x40405643d711d583 // .quad 4629795266307937667 + QUAD $0xdd95317f31c7fa1d // .quad -2480021597431793123 + QUAD $0x482835ea666b2572 // .quad 5199465050656154994 + QUAD $0x8a7d3eef7f1cfc52 // .quad -8467542526035952558 + QUAD $0xda3243650005eecf // .quad -2724040723534582065 + QUAD $0xad1c8eab5ee43b66 // .quad -5972742139117552794 + QUAD $0x90bed43e40076a82 // .quad -8016736922845615486 + QUAD $0xd863b256369d4a40 // .quad -2854241655469553088 + QUAD $0x5a7744a6e804a291 // .quad 6518754469289960081 + QUAD $0x873e4f75e2224e68 // .quad -8701430062309552536 + QUAD $0x711515d0a205cb36 // .quad 8148443086612450102 + QUAD $0xa90de3535aaae202 // .quad -6265101559459552766 + QUAD $0x0d5a5b44ca873e03 // .quad 962181821410786819 + QUAD $0xd3515c2831559a83 // .quad -3219690930897053053 + QUAD $0xe858790afe9486c2 // .quad -1704479370831952190 + QUAD $0x8412d9991ed58091 // .quad -8929835859451740015 + QUAD $0x626e974dbe39a872 // .quad 7092772823314835570 + QUAD $0xa5178fff668ae0b6 // .quad -6550608805887287114 + QUAD $0xfb0a3d212dc8128f // .quad -357406007711231345 + QUAD $0xce5d73ff402d98e3 // .quad -3576574988931720989 + QUAD $0x7ce66634bc9d0b99 // .quad 8999993282035256217 + QUAD $0x80fa687f881c7f8e // .quad -9152888395723407474 + QUAD $0x1c1fffc1ebc44e80 // .quad 2026619565689294464 + QUAD $0xa139029f6a239f72 // .quad -6829424476226871438 + QUAD $0xa327ffb266b56220 // .quad -6690097579743157728 + QUAD $0xc987434744ac874e // .quad -3925094576856201394 + QUAD $0x4bf1ff9f0062baa8 // .quad 5472436080603216552 + QUAD $0xfbe9141915d7a922 // .quad -294682202642863838 + QUAD $0x6f773fc3603db4a9 // .quad 8031958568804398249 + QUAD $0x9d71ac8fada6c9b5 // .quad -7101705404292871755 + QUAD $0xcb550fb4384d21d3 // .quad -3795109844276665901 + QUAD $0xc4ce17b399107c22 // .quad -4265445736938701790 + QUAD $0x7e2a53a146606a48 // .quad 9091170749936331336 + QUAD $0xf6019da07f549b2b // .quad -720121152745989333 + QUAD $0x2eda7444cbfc426d // .quad 3376138709496513133 + QUAD $0x99c102844f94e0fb // .quad -7367604748107325189 + QUAD $0xfa911155fefb5308 // .quad -391512631556746488 + QUAD $0xc0314325637a1939 // .quad -4597819916706768583 + QUAD $0x793555ab7eba27ca // .quad 8733981247408842698 + QUAD $0xf03d93eebc589f88 // .quad -1135588877456072824 + QUAD $0x4bc1558b2f3458de // .quad 5458738279630526686 + QUAD $0x96267c7535b763b5 // .quad -7627272076051127371 + QUAD $0x9eb1aaedfb016f16 // .quad -7011635205744005354 + QUAD $0xbbb01b9283253ca2 // .quad -4922404076636521310 + QUAD $0x465e15a979c1cadc // .quad 5070514048102157020 + QUAD $0xea9c227723ee8bcb // .quad -1541319077368263733 + QUAD $0x0bfacd89ec191ec9 // .quad 863228270850154185 + QUAD $0x92a1958a7675175f // .quad -7880853450996246689 + QUAD $0xcef980ec671f667b // .quad -3532650679864695173 + QUAD $0xb749faed14125d36 // .quad -5239380795317920458 + QUAD $0x82b7e12780e7401a // .quad -9027499368258256870 + QUAD $0xe51c79a85916f484 // .quad -1937539975720012668 + QUAD $0xd1b2ecb8b0908810 // .quad -3336344095947716592 + QUAD $0x8f31cc0937ae58d2 // .quad -8128491512466089774 + QUAD $0x861fa7e6dcb4aa15 // .quad -8782116138362033643 + QUAD $0xb2fe3f0b8599ef07 // .quad -5548928372155224313 + QUAD $0x67a791e093e1d49a // .quad 7469098900757009562 + QUAD $0xdfbdcece67006ac9 // .quad -2324474446766642487 + QUAD $0xe0c8bb2c5c6d24e0 // .quad -2249342214667950880 + QUAD $0x8bd6a141006042bd // .quad -8370325556870233411 + QUAD $0x58fae9f773886e18 // .quad 6411694268519837208 + QUAD $0xaecc49914078536d // .quad -5851220927660403859 + QUAD $0xaf39a475506a899e // .quad -5820440219632367202 + QUAD $0xda7f5bf590966848 // .quad -2702340141148116920 + QUAD $0x6d8406c952429603 // .quad 7891439908798240259 + QUAD $0x888f99797a5e012d // .quad -8606491615858654931 + QUAD $0xc8e5087ba6d33b83 // .quad -3970758169284363389 + QUAD $0xaab37fd7d8f58178 // .quad -6146428501395930760 + QUAD $0xfb1e4a9a90880a64 // .quad -351761693178066332 + QUAD $0xd5605fcdcf32e1d6 // .quad -3071349608317525546 + QUAD $0x5cf2eea09a55067f // .quad 6697677969404790399 + QUAD $0x855c3be0a17fcd26 // .quad -8837122532839535322 + QUAD $0xf42faa48c0ea481e // .quad -851274575098787810 + QUAD $0xa6b34ad8c9dfc06f // .quad -6434717147622031249 + QUAD $0xf13b94daf124da26 // .quad -1064093218873484762 + QUAD $0xd0601d8efc57b08b // .quad -3431710416100151157 + QUAD $0x76c53d08d6b70858 // .quad 8558313775058847832 + QUAD $0x823c12795db6ce57 // .quad -9062348037703676329 + QUAD $0x54768c4b0c64ca6e // .quad 6086206200396171886 + QUAD $0xa2cb1717b52481ed // .quad -6716249028702207507 + QUAD $0xa9942f5dcf7dfd09 // .quad -6227300304786948855 + QUAD $0xcb7ddcdda26da268 // .quad -3783625267450371480 + QUAD $0xd3f93b35435d7c4c // .quad -3172439362556298164 + QUAD $0xfe5d54150b090b02 // .quad -117845565885576446 + QUAD $0xc47bc5014a1a6daf // .quad -4288617610811380305 + QUAD $0x9efa548d26e5a6e1 // .quad -6991182506319567135 + QUAD $0x359ab6419ca1091b // .quad 3862600023340550427 + QUAD $0xc6b8e9b0709f109a // .quad -4127292114472071014 + QUAD $0xc30163d203c94b62 // .quad -4395122007679087774 + QUAD $0xf867241c8cc6d4c0 // .quad -547429124662700864 + QUAD $0x79e0de63425dcf1d // .quad 8782263791269039901 + QUAD $0x9b407691d7fc44f8 // .quad -7259672230555269896 + QUAD $0x985915fc12f542e4 // .quad -7468914334623251740 + QUAD $0xc21094364dfb5636 // .quad -4462904269766699466 + QUAD $0x3e6f5b7b17b2939d // .quad 4498915137003099037 + QUAD $0xf294b943e17a2bc4 // .quad -966944318780986428 + QUAD $0xa705992ceecf9c42 // .quad -6411550076227838910 + QUAD $0x979cf3ca6cec5b5a // .quad -7521869226879198374 + QUAD $0x50c6ff782a838353 // .quad 5820620459997365075 + QUAD $0xbd8430bd08277231 // .quad -4790650515171610063 + QUAD $0xa4f8bf5635246428 // .quad -6559282480285457368 + QUAD $0xece53cec4a314ebd // .quad -1376627125537124675 + QUAD $0x871b7795e136be99 // .quad -8711237568605798759 + QUAD $0x940f4613ae5ed136 // .quad -7777920981101784778 + QUAD $0x28e2557b59846e3f // .quad 2946011094524915263 + QUAD $0xb913179899f68584 // .quad -5110715207949843068 + QUAD $0x331aeada2fe589cf // .quad 3682513868156144079 + QUAD $0xe757dd7ec07426e5 // .quad -1776707991509915931 + QUAD $0x3ff0d2c85def7621 // .quad 4607414176811284001 + QUAD $0x9096ea6f3848984f // .quad -8027971522334779313 + QUAD $0x0fed077a756b53a9 // .quad 1147581702586717097 + QUAD $0xb4bca50b065abe63 // .quad -5423278384491086237 + QUAD $0xd3e8495912c62894 // .quad -3177208890193991532 + QUAD $0xe1ebce4dc7f16dfb // .quad -2167411962186469893 + QUAD $0x64712dd7abbbd95c // .quad 7237616480483531100 + QUAD $0x8d3360f09cf6e4bd // .quad -8272161504007625539 + QUAD $0xbd8d794d96aacfb3 // .quad -4788037454677749837 + QUAD $0xb080392cc4349dec // .quad -5728515861582144020 + QUAD $0xecf0d7a0fc5583a0 // .quad -1373360799919799392 + QUAD $0xdca04777f541c567 // .quad -2548958808550292121 + QUAD $0xf41686c49db57244 // .quad -858350499949874620 + QUAD $0x89e42caaf9491b60 // .quad -8510628282985014432 + QUAD $0x311c2875c522ced5 // .quad 3538747893490044629 + QUAD $0xac5d37d5b79b6239 // .quad -6026599335303880135 + QUAD $0x7d633293366b828b // .quad 9035120885289943691 + QUAD $0xd77485cb25823ac7 // .quad -2921563150702462265 + QUAD $0xae5dff9c02033197 // .quad -5882264492762254953 + QUAD $0x86a8d39ef77164bc // .quad -8743505996830120772 + QUAD $0xd9f57f830283fdfc // .quad -2741144597525430788 + QUAD $0xa8530886b54dbdeb // .quad -6317696477610263061 + QUAD $0xd072df63c324fd7b // .quad -3426430746906788485 + QUAD $0xd267caa862a12d66 // .quad -3285434578585440922 + QUAD $0x4247cb9e59f71e6d // .quad 4776009810824339053 + QUAD $0x8380dea93da4bc60 // .quad -8970925639256982432 + QUAD $0x52d9be85f074e608 // .quad 5970012263530423816 + QUAD $0xa46116538d0deb78 // .quad -6601971030643840136 + QUAD $0x67902e276c921f8b // .quad 7462515329413029771 + QUAD $0xcd795be870516656 // .quad -3640777769877412266 + QUAD $0x00ba1cd8a3db53b6 // .quad 52386062455755702 + QUAD $0x806bd9714632dff6 // .quad -9193015133814464522 + QUAD $0x80e8a40eccd228a4 // .quad -9157889458785081180 + QUAD $0xa086cfcd97bf97f3 // .quad -6879582898840692749 + QUAD $0x6122cd128006b2cd // .quad 6999382250228200141 + QUAD $0xc8a883c0fdaf7df0 // .quad -3987792605123478032 + QUAD $0x796b805720085f81 // .quad 8749227812785250177 + QUAD $0xfad2a4b13d1b5d6c // .quad -373054737976959636 + QUAD $0xcbe3303674053bb0 // .quad -3755104653863994448 + QUAD $0x9cc3a6eec6311a63 // .quad -7150688238876681629 + QUAD $0xbedbfc4411068a9c // .quad -4693880817329993060 + QUAD $0xc3f490aa77bd60fc // .quad -4326674280168464132 + QUAD $0xee92fb5515482d44 // .quad -1255665003235103420 + QUAD $0xf4f1b4d515acb93b // .quad -796656831783192261 + QUAD $0x751bdd152d4d1c4a // .quad 8438581409832836170 + QUAD $0x991711052d8bf3c5 // .quad -7415439547505577019 + QUAD $0xd262d45a78a0635d // .quad -3286831292991118499 + QUAD $0xbf5cd54678eef0b6 // .quad -4657613415954583370 + QUAD $0x86fb897116c87c34 // .quad -8720225134666286028 + QUAD $0xef340a98172aace4 // .quad -1210330751515841308 + QUAD $0xd45d35e6ae3d4da0 // .quad -3144297699952734816 + QUAD $0x9580869f0e7aac0e // .quad -7673985747338482674 + QUAD $0x8974836059cca109 // .quad -8542058143368306423 + QUAD $0xbae0a846d2195712 // .quad -4980796165745715438 + QUAD $0x2bd1a438703fc94b // .quad 3157485376071780683 + QUAD $0xe998d258869facd7 // .quad -1614309188754756393 + QUAD $0x7b6306a34627ddcf // .quad 8890957387685944783 + QUAD $0x91ff83775423cc06 // .quad -7926472270612804602 + QUAD $0x1a3bc84c17b1d542 // .quad 1890324697752655170 + QUAD $0xb67f6455292cbf08 // .quad -5296404319838617848 + QUAD $0x20caba5f1d9e4a93 // .quad 2362905872190818963 + QUAD $0xe41f3d6a7377eeca // .quad -2008819381370884406 + QUAD $0x547eb47b7282ee9c // .quad 6088502188546649756 + QUAD $0x8e938662882af53e // .quad -8173041140997884610 + QUAD $0xe99e619a4f23aa43 // .quad -1612744301171463613 + QUAD $0xb23867fb2a35b28d // .quad -5604615407819967859 + QUAD $0x6405fa00e2ec94d4 // .quad 7207441660390446292 + QUAD $0xdec681f9f4c31f31 // .quad -2394083241347571919 + QUAD $0xde83bc408dd3dd04 // .quad -2412877989897052924 + QUAD $0x8b3c113c38f9f37e // .quad -8413831053483314306 + QUAD $0x9624ab50b148d445 // .quad -7627783505798704059 + QUAD $0xae0b158b4738705e // .quad -5905602798426754978 + QUAD $0x3badd624dd9b0957 // .quad 4300328673033783639 + QUAD $0xd98ddaee19068c76 // .quad -2770317479606055818 + QUAD $0xe54ca5d70a80e5d6 // .quad -1923980597781273130 + QUAD $0x87f8a8d4cfa417c9 // .quad -8648977452394866743 + QUAD $0x5e9fcf4ccd211f4c // .quad 6818396289628184396 + QUAD $0xa9f6d30a038d1dbc // .quad -6199535797066195524 + QUAD $0x7647c3200069671f // .quad 8522995362035230495 + QUAD $0xd47487cc8470652b // .quad -3137733727905356501 + QUAD $0x29ecd9f40041e073 // .quad 3021029092058325107 + QUAD $0x84c8d4dfd2c63f3b // .quad -8878612607581929669 + QUAD $0xf468107100525890 // .quad -835399653354481520 + QUAD $0xa5fb0a17c777cf09 // .quad -6486579741050024183 + QUAD $0x7182148d4066eeb4 // .quad 8179122470161673908 + QUAD $0xcf79cc9db955c2cc // .quad -3496538657885142324 + QUAD $0xc6f14cd848405530 // .quad -4111420493003729616 + QUAD $0x81ac1fe293d599bf // .quad -9102865688819295809 + QUAD $0xb8ada00e5a506a7c // .quad -5139275616254662020 + QUAD $0xa21727db38cb002f // .quad -6766896092596731857 + QUAD $0xa6d90811f0e4851c // .quad -6424094520318327524 + QUAD $0xca9cf1d206fdc03b // .quad -3846934097318526917 + QUAD $0x908f4a166d1da663 // .quad -8030118150397909405 + QUAD $0xfd442e4688bd304a // .quad -196981603220770742 + QUAD $0x9a598e4e043287fe // .quad -7324666853212387330 + QUAD $0x9e4a9cec15763e2e // .quad -7040642529654063570 + QUAD $0x40eff1e1853f29fd // .quad 4679224488766679549 + QUAD $0xc5dd44271ad3cdba // .quad -4189117143640191558 + QUAD $0xd12bee59e68ef47c // .quad -3374341425896426372 + QUAD $0xf7549530e188c128 // .quad -624710411122851544 + QUAD $0x82bb74f8301958ce // .quad -9026492418826348338 + QUAD $0x9a94dd3e8cf578b9 // .quad -7307973034592864071 + QUAD $0xe36a52363c1faf01 // .quad -2059743486678159615 + QUAD $0xc13a148e3032d6e7 // .quad -4523280274813692185 + QUAD $0xdc44e6c3cb279ac1 // .quad -2574679358347699519 + QUAD $0xf18899b1bc3f8ca1 // .quad -1042414325089727327 + QUAD $0x29ab103a5ef8c0b9 // .quad 3002511419460075705 + QUAD $0x96f5600f15a7b7e5 // .quad -7569037980822161435 + QUAD $0x7415d448f6b6f0e7 // .quad 8364825292752482535 + QUAD $0xbcb2b812db11a5de // .quad -4849611457600313890 + QUAD $0x111b495b3464ad21 // .quad 1232659579085827361 + QUAD $0xebdf661791d60f56 // .quad -1450328303573004458 + QUAD $0xcab10dd900beec34 // .quad -3841273781498745804 + QUAD $0x936b9fcebb25c995 // .quad -7823984217374209643 + QUAD $0x3d5d514f40eea742 // .quad 4421779809981343554 + QUAD $0xb84687c269ef3bfb // .quad -5168294253290374149 + QUAD $0x0cb4a5a3112a5112 // .quad 915538744049291538 + QUAD $0xe65829b3046b0afa // .quad -1848681798185579782 + QUAD $0x47f0e785eaba72ab // .quad 5183897733458195115 + QUAD $0x8ff71a0fe2c2e6dc // .quad -8072955151507069220 + QUAD $0x59ed216765690f56 // .quad 6479872166822743894 + QUAD $0xb3f4e093db73a093 // .quad -5479507920956448621 + QUAD $0x306869c13ec3532c // .quad 3488154190101041964 + QUAD $0xe0f218b8d25088b8 // .quad -2237698882768172872 + QUAD $0x1e414218c73a13fb // .quad 2180096368813151227 + QUAD $0x8c974f7383725573 // .quad -8316090829371189901 + QUAD $0xe5d1929ef90898fa // .quad -1886565557410948870 + QUAD $0xafbd2350644eeacf // .quad -5783427518286599473 + QUAD $0xdf45f746b74abf39 // .quad -2358206946763686087 + QUAD $0xdbac6c247d62a583 // .quad -2617598379430861437 + QUAD $0x6b8bba8c328eb783 // .quad 7749492695127472003 + QUAD $0x894bc396ce5da772 // .quad -8553528014785370254 + QUAD $0x066ea92f3f326564 // .quad 463493832054564196 + QUAD $0xab9eb47c81f5114f // .quad -6080224000054324913 + QUAD $0xc80a537b0efefebd // .quad -4032318728359182659 + QUAD $0xd686619ba27255a2 // .quad -2988593981640518238 + QUAD $0xbd06742ce95f5f36 // .quad -4826042214438183114 + QUAD $0x8613fd0145877585 // .quad -8785400266166405755 + QUAD $0x2c48113823b73704 // .quad 3190819268807046916 + QUAD $0xa798fc4196e952e7 // .quad -6370064314280619289 + QUAD $0xf75a15862ca504c5 // .quad -623161932418579259 + QUAD $0xd17f3b51fca3a7a0 // .quad -3350894374423386208 + QUAD $0x9a984d73dbe722fb // .quad -7307005235402693893 + QUAD $0x82ef85133de648c4 // .quad -9011838011655698236 + QUAD $0xc13e60d0d2e0ebba // .quad -4522070525825979462 + QUAD $0xa3ab66580d5fdaf5 // .quad -6653111496142234891 + QUAD $0x318df905079926a8 // .quad 3570783879572301480 + QUAD $0xcc963fee10b7d1b3 // .quad -3704703351750405709 + QUAD $0xfdf17746497f7052 // .quad -148206168962011054 + QUAD $0xffbbcfe994e5c61f // .quad -19193171260619233 + QUAD $0xfeb6ea8bedefa633 // .quad -92628855601256909 + QUAD $0x9fd561f1fd0f9bd3 // .quad -6929524759678968877 + QUAD $0xfe64a52ee96b8fc0 // .quad -115786069501571136 + QUAD $0xc7caba6e7c5382c8 // .quad -4050219931171323192 + QUAD $0x3dfdce7aa3c673b0 // .quad 4466953431550423984 + QUAD $0xf9bd690a1b68637b // .quad -451088895536766085 + QUAD $0x06bea10ca65c084e // .quad 486002885505321038 + QUAD $0x9c1661a651213e2d // .quad -7199459587351560659 + QUAD $0x486e494fcff30a62 // .quad 5219189625309039202 + QUAD $0xc31bfa0fe5698db8 // .quad -4387638465762062920 + QUAD $0x5a89dba3c3efccfa // .quad 6523987031636299002 + QUAD $0xf3e2f893dec3f126 // .quad -872862063775190746 + QUAD $0xf89629465a75e01c // .quad -534194123654701028 + QUAD $0x986ddb5c6b3a76b7 // .quad -7463067817500576073 + QUAD $0xf6bbb397f1135823 // .quad -667742654568376285 + QUAD $0xbe89523386091465 // .quad -4717148753448332187 + QUAD $0x746aa07ded582e2c // .quad 8388693718644305452 + QUAD $0xee2ba6c0678b597f // .quad -1284749923383027329 + QUAD $0xa8c2a44eb4571cdc // .quad -6286281471915778852 + QUAD $0x94db483840b717ef // .quad -7720497729755473937 + QUAD $0x92f34d62616ce413 // .quad -7857851839894723565 + QUAD $0xba121a4650e4ddeb // .quad -5038936143766954517 + QUAD $0x77b020baf9c81d17 // .quad 8624429273841147159 + QUAD $0xe896a0d7e51e1566 // .quad -1686984161281305242 + QUAD $0x0ace1474dc1d122e // .quad 778582277723329070 + QUAD $0x915e2486ef32cd60 // .quad -7971894128441897632 + QUAD $0x0d819992132456ba // .quad 973227847154161338 + QUAD $0xb5b5ada8aaff80b8 // .quad -5353181642124984136 + QUAD $0x10e1fff697ed6c69 // .quad 1216534808942701673 + QUAD $0xe3231912d5bf60e6 // .quad -2079791034228842266 + QUAD $0xca8d3ffa1ef463c1 // .quad -3851351762838199359 + QUAD $0x8df5efabc5979c8f // .quad -8217398424034108273 + QUAD $0xbd308ff8a6b17cb2 // .quad -4814189703547749198 + QUAD $0xb1736b96b6fd83b3 // .quad -5660062011615247437 + QUAD $0xac7cb3f6d05ddbde // .quad -6017737129434686498 + QUAD $0xddd0467c64bce4a0 // .quad -2463391496091671392 + QUAD $0x6bcdf07a423aa96b // .quad 7768129340171790699 + QUAD $0x8aa22c0dbef60ee4 // .quad -8457148712698376476 + QUAD $0x86c16c98d2c953c6 // .quad -8736582398494813242 + QUAD $0xad4ab7112eb3929d // .quad -5959749872445582691 + QUAD $0xe871c7bf077ba8b7 // .quad -1697355961263740745 + QUAD $0xd89d64d57a607744 // .quad -2838001322129590460 + QUAD $0x11471cd764ad4972 // .quad 1244995533423855986 + QUAD $0x87625f056c7c4a8b // .quad -8691279853972075893 + QUAD $0xd598e40d3dd89bcf // .quad -3055441601647567921 + QUAD $0xa93af6c6c79b5d2d // .quad -6252413799037706963 + QUAD $0x4aff1d108d4ec2c3 // .quad 5404070034795315907 + QUAD $0xd389b47879823479 // .quad -3203831230369745799 + QUAD $0xcedf722a585139ba // .quad -3539985255894009414 + QUAD $0x843610cb4bf160cb // .quad -8919923546622172981 + QUAD $0xc2974eb4ee658828 // .quad -4424981569867511768 + QUAD $0xa54394fe1eedb8fe // .quad -6538218414850328322 + QUAD $0x733d226229feea32 // .quad 8303831092947774002 + QUAD $0xce947a3da6a9273e // .quad -3561087000135522498 + QUAD $0x0806357d5a3f525f // .quad 578208414664970847 + QUAD $0x811ccc668829b887 // .quad -9143208402725783417 + QUAD $0xca07c2dcb0cf26f7 // .quad -3888925500096174345 + QUAD $0xa163ff802a3426a8 // .quad -6817324484979841368 + QUAD $0xfc89b393dd02f0b5 // .quad -249470856692830027 + QUAD $0xc9bcff6034c13052 // .quad -3909969587797413806 + QUAD $0xbbac2078d443ace2 // .quad -4923524589293425438 + QUAD $0xfc2c3f3841f17c67 // .quad -275775966319379353 + QUAD $0xd54b944b84aa4c0d // .quad -3077202868308390899 + QUAD $0x9d9ba7832936edc0 // .quad -7089889006590693952 + QUAD $0x0a9e795e65d4df11 // .quad 765182433041899281 + QUAD $0xc5029163f384a931 // .quad -4250675239810979535 + QUAD $0x4d4617b5ff4a16d5 // .quad 5568164059729762005 + QUAD $0xf64335bcf065d37d // .quad -701658031336336515 + QUAD $0x504bced1bf8e4e45 // .quad 5785945546544795205 + QUAD $0x99ea0196163fa42e // .quad -7356065297226292178 + QUAD $0xe45ec2862f71e1d6 // .quad -1990940103673781802 + QUAD $0xc06481fb9bcf8d39 // .quad -4583395603105477319 + QUAD $0x5d767327bb4e5a4c // .quad 6734696907262548556 + QUAD $0xf07da27a82c37088 // .quad -1117558485454458744 + QUAD $0x3a6a07f8d510f86f // .quad 4209185567039092847 + QUAD $0x964e858c91ba2655 // .quad -7616003081050118571 + QUAD $0x890489f70a55368b // .quad -8573576096483297653 + QUAD $0xbbe226efb628afea // .quad -4908317832885260310 + QUAD $0x2b45ac74ccea842e // .quad 3118087934678041646 + QUAD $0xeadab0aba3b2dbe5 // .quad -1523711272679187483 + QUAD $0x3b0b8bc90012929d // .quad 4254647968387469981 + QUAD $0x92c8ae6b464fc96f // .quad -7869848573065574033 + QUAD $0x09ce6ebb40173744 // .quad 706623942056949572 + QUAD $0xb77ada0617e3bbcb // .quad -5225624697904579637 + QUAD $0xcc420a6a101d0515 // .quad -3728406090856200939 + QUAD $0xe55990879ddcaabd // .quad -1920344853953336643 + QUAD $0x9fa946824a12232d // .quad -6941939825212513491 + QUAD $0x8f57fa54c2a9eab6 // .quad -8117744561361917258 + QUAD $0x47939822dc96abf9 // .quad 5157633273766521849 + QUAD $0xb32df8e9f3546564 // .quad -5535494683275008668 + QUAD $0x59787e2b93bc56f7 // .quad 6447041592208152311 + QUAD $0xdff9772470297ebd // .quad -2307682335666372931 + QUAD $0x57eb4edb3c55b65a // .quad 6335244004343789146 + QUAD $0x8bfbea76c619ef36 // .quad -8359830487432564938 + QUAD $0xede622920b6b23f1 // .quad -1304317031425039375 + QUAD $0xaefae51477a06b03 // .quad -5838102090863318269 + QUAD $0xe95fab368e45eced // .quad -1630396289281299219 + QUAD $0xdab99e59958885c4 // .quad -2685941595151759932 + QUAD $0x11dbcb0218ebb414 // .quad 1286845328412881940 + QUAD $0x88b402f7fd75539b // .quad -8596242524610931813 + QUAD $0xd652bdc29f26a119 // .quad -3003129357911285479 + QUAD $0xaae103b5fcd2a881 // .quad -6133617137336276863 + QUAD $0x4be76d3346f0495f // .quad 5469460339465668959 + QUAD $0xd59944a37c0752a2 // .quad -3055335403242958174 + QUAD $0x6f70a4400c562ddb // .quad 8030098730593431003 + QUAD $0x857fcae62d8493a5 // .quad -8827113654667930715 + QUAD $0xcb4ccd500f6bb952 // .quad -3797434642040374958 + QUAD $0xa6dfbd9fb8e5b88e // .quad -6422206049907525490 + QUAD $0x7e2000a41346a7a7 // .quad 9088264752731695015 + QUAD $0xd097ad07a71f26b2 // .quad -3416071543957018958 + QUAD $0x8ed400668c0c28c8 // .quad -8154892584824854328 + QUAD $0x825ecc24c873782f // .quad -9052573742614218705 + QUAD $0x728900802f0f32fa // .quad 8253128342678483706 + QUAD $0xa2f67f2dfa90563b // .quad -6704031159840385477 + QUAD $0x4f2b40a03ad2ffb9 // .quad 5704724409920716729 + QUAD $0xcbb41ef979346bca // .quad -3768352931373093942 + QUAD $0xe2f610c84987bfa8 // .quad -2092466524453879896 + QUAD $0xfea126b7d78186bc // .quad -98755145788979524 + QUAD $0x0dd9ca7d2df4d7c9 // .quad 998051431430019017 + QUAD $0x9f24b832e6b0f436 // .quad -6979250993759194058 + QUAD $0x91503d1c79720dbb // .quad -7975807747567252037 + QUAD $0xc6ede63fa05d3143 // .quad -4112377723771604669 + QUAD $0x75a44c6397ce912a // .quad 8476984389250486570 + QUAD $0xf8a95fcf88747d94 // .quad -528786136287117932 + QUAD $0xc986afbe3ee11aba // .quad -3925256793573221702 + QUAD $0x9b69dbe1b548ce7c // .quad -7248020362820530564 + QUAD $0xfbe85badce996168 // .quad -294884973539139224 + QUAD $0xc24452da229b021b // .quad -4448339435098275301 + QUAD $0xfae27299423fb9c3 // .quad -368606216923924029 + QUAD $0xf2d56790ab41c2a2 // .quad -948738275445456222 + QUAD $0xdccd879fc967d41a // .quad -2536221894791146470 + QUAD $0x97c560ba6b0919a5 // .quad -7510490449794491995 + QUAD $0x5400e987bbc1c920 // .quad 6053094668365842720 + QUAD $0xbdb6b8e905cb600f // .quad -4776427043815727089 + QUAD $0x290123e9aab23b68 // .quad 2954682317029915496 + QUAD $0xed246723473e3813 // .quad -1358847786342270957 + QUAD $0xf9a0b6720aaf6521 // .quad -459166561069996767 + QUAD $0x9436c0760c86e30b // .quad -7766808894105001205 + QUAD $0xf808e40e8d5b3e69 // .quad -573958201337495959 + QUAD $0xb94470938fa89bce // .quad -5096825099203863602 + QUAD $0xb60b1d1230b20e04 // .quad -5329133770099257852 + QUAD $0xe7958cb87392c2c2 // .quad -1759345355577441598 + QUAD $0xb1c6f22b5e6f48c2 // .quad -5636551615525730110 + QUAD $0x90bd77f3483bb9b9 // .quad -8017119874876982855 + QUAD $0x1e38aeb6360b1af3 // .quad 2177682517447613171 + QUAD $0xb4ecd5f01a4aa828 // .quad -5409713825168840664 + QUAD $0x25c6da63c38de1b0 // .quad 2722103146809516464 + QUAD $0xe2280b6c20dd5232 // .quad -2150456263033662926 + QUAD $0x579c487e5a38ad0e // .quad 6313000485183335694 + QUAD $0x8d590723948a535f // .quad -8261564192037121185 + QUAD $0x2d835a9df0c6d851 // .quad 3279564588051781713 + QUAD $0xb0af48ec79ace837 // .quad -5715269221619013577 + QUAD $0xf8e431456cf88e65 // .quad -512230283362660763 + QUAD $0xdcdb1b2798182244 // .quad -2532400508596379068 + QUAD $0x1b8e9ecb641b58ff // .quad 1985699082112030975 + QUAD $0x8a08f0f8bf0f156b // .quad -8500279345513818773 + QUAD $0xe272467e3d222f3f // .quad -2129562165787349185 + QUAD $0xac8b2d36eed2dac5 // .quad -6013663163464885563 + QUAD $0x5b0ed81dcc6abb0f // .quad 6561419329620589327 + QUAD $0xd7adf884aa879177 // .quad -2905392935903719049 + QUAD $0x98e947129fc2b4e9 // .quad -7428327965055601431 + QUAD $0x86ccbb52ea94baea // .quad -8733399612580906262 + QUAD $0x3f2398d747b36224 // .quad 4549648098962661924 + QUAD $0xa87fea27a539e9a5 // .quad -6305063497298744923 + QUAD $0x8eec7f0d19a03aad // .quad -8147997931578836307 + QUAD $0xd29fe4b18e88640e // .quad -3269643353196043250 + QUAD $0x1953cf68300424ac // .quad 1825030320404309164 + QUAD $0x83a3eeeef9153e89 // .quad -8961056123388608887 + QUAD $0x5fa8c3423c052dd7 // .quad 6892973918932774359 + QUAD $0xa48ceaaab75a8e2b // .quad -6589634135808373205 + QUAD $0x3792f412cb06794d // .quad 4004531380238580045 + QUAD $0xcdb02555653131b6 // .quad -3625356651333078602 + QUAD $0xe2bbd88bbee40bd0 // .quad -2108853905778275376 + QUAD $0x808e17555f3ebf11 // .quad -9183376934724255983 + QUAD $0x5b6aceaeae9d0ec4 // .quad 6587304654631931588 + QUAD $0xa0b19d2ab70e6ed6 // .quad -6867535149977932074 + QUAD $0xf245825a5a445275 // .quad -989241218564861323 + QUAD $0xc8de047564d20a8b // .quad -3972732919045027189 + QUAD $0xeed6e2f0f0d56712 // .quad -1236551523206076654 + QUAD $0xfb158592be068d2e // .quad -354230130378896082 + QUAD $0x55464dd69685606b // .quad 6144684325637283947 + QUAD $0x9ced737bb6c4183d // .quad -7138922859127891907 + QUAD $0xaa97e14c3c26b886 // .quad -6154202648235558778 + QUAD $0xc428d05aa4751e4c // .quad -4311967555482476980 + QUAD $0xd53dd99f4b3066a8 // .quad -3081067291867060568 + QUAD $0xf53304714d9265df // .quad -778273425925708321 + QUAD $0xe546a8038efe4029 // .quad -1925667057416912855 + QUAD $0x993fe2c6d07b7fab // .quad -7403949918844649557 + QUAD $0xde98520472bdd033 // .quad -2407083821771141069 + QUAD $0xbf8fdb78849a5f96 // .quad -4643251380128424042 + QUAD $0x963e66858f6d4440 // .quad -7620540795641314240 + QUAD $0xef73d256a5c0f77c // .quad -1192378206733142148 + QUAD $0xdde7001379a44aa8 // .quad -2456994988062127448 + QUAD $0x95a8637627989aad // .quad -7662765406849295699 + QUAD $0x5560c018580d5d52 // .quad 6152128301777116498 + QUAD $0xbb127c53b17ec159 // .quad -4966770740134231719 + QUAD $0xaab8f01e6e10b4a6 // .quad -6144897678060768090 + QUAD $0xe9d71b689dde71af // .quad -1596777406740401745 + QUAD $0xcab3961304ca70e8 // .quad -3840561048787980056 + QUAD $0x9226712162ab070d // .quad -7915514906853832947 + QUAD $0x3d607b97c5fd0d22 // .quad 4422670725869800738 + QUAD $0xb6b00d69bb55c8d1 // .quad -5282707615139903279 + QUAD $0x8cb89a7db77c506a // .quad -8306719647944912790 + QUAD $0xe45c10c42a2b3b05 // .quad -1991698500497491195 + QUAD $0x77f3608e92adb242 // .quad 8643358275316593218 + QUAD $0x8eb98a7a9a5b04e3 // .quad -8162340590452013853 + QUAD $0x55f038b237591ed3 // .quad 6192511825718353619 + QUAD $0xb267ed1940f1c61c // .quad -5591239719637629412 + QUAD $0x6b6c46dec52f6688 // .quad 7740639782147942024 + QUAD $0xdf01e85f912e37a3 // .quad -2377363631119648861 + QUAD $0x2323ac4b3b3da015 // .quad 2532056854628769813 + QUAD $0x8b61313bbabce2c6 // .quad -8403381297090862394 + QUAD $0xabec975e0a0d081a // .quad -6058300968568813542 + QUAD $0xae397d8aa96c1b77 // .quad -5892540602936190089 + QUAD $0x96e7bd358c904a21 // .quad -7572876210711016927 + QUAD $0xd9c7dced53c72255 // .quad -2753989735242849707 + QUAD $0x7e50d64177da2e54 // .quad 9102010423587778132 + QUAD $0x881cea14545c7575 // .quad -8638772612167862923 + QUAD $0xdde50bd1d5d0b9e9 // .quad -2457545025797441047 + QUAD $0xaa242499697392d2 // .quad -6186779746782440750 + QUAD $0x955e4ec64b44e864 // .quad -7683617300674189212 + QUAD $0xd4ad2dbfc3d07787 // .quad -3121788665050663033 + QUAD $0xbd5af13bef0b113e // .quad -4802260812921368258 + QUAD $0x84ec3c97da624ab4 // .quad -8868646943297746252 + QUAD $0xecb1ad8aeacdd58e // .quad -1391139997724322418 + QUAD $0xa6274bbdd0fadd61 // .quad -6474122660694794911 + QUAD $0x67de18eda5814af2 // .quad 7484447039699372786 + QUAD $0xcfb11ead453994ba // .quad -3480967307441105734 + QUAD $0x80eacf948770ced7 // .quad -9157278655470055721 + QUAD $0x81ceb32c4b43fcf4 // .quad -9093133594791772940 + QUAD $0xa1258379a94d028d // .quad -6834912300910181747 + QUAD $0xa2425ff75e14fc31 // .quad -6754730975062328271 + QUAD $0x096ee45813a04330 // .quad 679731660717048624 + QUAD $0xcad2f7f5359a3b3e // .quad -3831727700400522434 + QUAD $0x8bca9d6e188853fc // .quad -8373707460958465028 + QUAD $0xfd87b5f28300ca0d // .quad -177973607073265139 + QUAD $0x775ea264cf55347d // .quad 8601490892183123069 + QUAD $0x9e74d1b791e07e48 // .quad -7028762532061872568 + QUAD $0x95364afe032a819d // .quad -7694880458480647779 + QUAD $0xc612062576589dda // .quad -4174267146649952806 + QUAD $0x3a83ddbd83f52204 // .quad 4216457482181353988 + QUAD $0xf79687aed3eec551 // .quad -606147914885053103 + QUAD $0xc4926a9672793542 // .quad -4282243101277735614 + QUAD $0x9abe14cd44753b52 // .quad -7296371474444240046 + QUAD $0x75b7053c0f178293 // .quad 8482254178684994195 + QUAD $0xc16d9a0095928a27 // .quad -4508778324627912153 + QUAD $0x5324c68b12dd6338 // .quad 5991131704928854840 + QUAD $0xf1c90080baf72cb1 // .quad -1024286887357502287 + QUAD $0xd3f6fc16ebca5e03 // .quad -3173071712060547581 + QUAD $0x971da05074da7bee // .quad -7557708332239520786 + QUAD $0x88f4bb1ca6bcf584 // .quad -8578025658503072380 + QUAD $0xbce5086492111aea // .quad -4835449396872013078 + QUAD $0x2b31e9e3d06c32e5 // .quad 3112525982153323237 + QUAD $0xec1e4a7db69561a5 // .quad -1432625727662628443 + QUAD $0x3aff322e62439fcf // .quad 4251171748059520975 + QUAD $0x9392ee8e921d5d07 // .quad -7812920107430224633 + QUAD $0x09befeb9fad487c2 // .quad 702278666647013314 + QUAD $0xb877aa3236a4b449 // .quad -5154464115860392887 + QUAD $0x4c2ebe687989a9b3 // .quad 5489534351736154547 + QUAD $0xe69594bec44de15b // .quad -1831394126398103205 + QUAD $0x0f9d37014bf60a10 // .quad 1125115960621402640 + QUAD $0x901d7cf73ab0acd9 // .quad -8062150356639896359 + QUAD $0x538484c19ef38c94 // .quad 6018080969204141204 + QUAD $0xb424dc35095cd80f // .quad -5466001927372482545 + QUAD $0x2865a5f206b06fb9 // .quad 2910915193077788601 + QUAD $0xe12e13424bb40e13 // .quad -2220816390788215277 + QUAD $0xf93f87b7442e45d3 // .quad -486521013540076077 + QUAD $0x8cbccc096f5088cb // .quad -8305539271883716405 + QUAD $0xf78f69a51539d748 // .quad -608151266925095096 + QUAD $0xafebff0bcb24aafe // .quad -5770238071427257602 + QUAD $0xb573440e5a884d1b // .quad -5371875102083756773 + QUAD $0xdbe6fecebdedd5be // .quad -2601111570856684098 + QUAD $0x31680a88f8953030 // .quad 3560107088838733872 + QUAD $0x89705f4136b4a597 // .quad -8543223759426509417 + QUAD $0xfdc20d2b36ba7c3d // .quad -161552157378970563 + QUAD $0xabcc77118461cefc // .quad -6067343680855748868 + QUAD $0x3d32907604691b4c // .quad 4409745821703674700 + QUAD $0xd6bf94d5e57a42bc // .quad -2972493582642298180 + QUAD $0xa63f9a49c2c1b10f // .quad -6467280898289979121 + QUAD $0x8637bd05af6c69b5 // .quad -8775337516792518219 + QUAD $0x0fcf80dc33721d53 // .quad 1139270913992301907 + QUAD $0xa7c5ac471b478423 // .quad -6357485877563259869 + QUAD $0xd3c36113404ea4a8 // .quad -3187597375937010520 + QUAD $0xd1b71758e219652b // .quad -3335171328526686933 + QUAD $0x645a1cac083126e9 // .quad 7231123676894144233 + QUAD $0x83126e978d4fdf3b // .quad -9002011107970261189 + QUAD $0x3d70a3d70a3d70a3 // .quad 4427218577690292387 + QUAD $0xa3d70a3d70a3d70a // .quad -6640827866535438582 + QUAD $0xcccccccccccccccc; QUAD $0xcccccccccccccccc // .space 16, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc' + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8000000000000000 // .quad -9223372036854775808 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa000000000000000 // .quad -6917529027641081856 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc800000000000000 // .quad -4035225266123964416 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xfa00000000000000 // .quad -432345564227567616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9c40000000000000 // .quad -7187745005283311616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc350000000000000 // .quad -4372995238176751616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xf424000000000000 // .quad -854558029293551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9896800000000000 // .quad -7451627795949551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xbebc200000000000 // .quad -4702848726509551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xee6b280000000000 // .quad -1266874889709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9502f90000000000 // .quad -7709325833709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xba43b74000000000 // .quad -5024971273709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe8d4a51000000000 // .quad -1669528073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9184e72a00000000 // .quad -7960984073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb5e620f480000000 // .quad -5339544073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe35fa931a0000000 // .quad -2062744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8ac7230489e80000 // .quad -8446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x878678326eac9000 // .quad -8681119073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa968163f0a57b400 // .quad -6239712823709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x84595161401484a0 // .quad -8910000909647051616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366 + QUAD $0x4000000000000000 // .quad 4611686018427387904 + QUAD $0x813f3978f8940984 // .quad -9133518327554766460 + QUAD $0x5000000000000000 // .quad 5764607523034234880 + QUAD $0xa18f07d736b90be5 // .quad -6805211891016070171 + QUAD $0xa400000000000000 // .quad -6629298651489370112 + QUAD $0xc9f2c9cd04674ede // .quad -3894828845342699810 + QUAD $0x4d00000000000000 // .quad 5548434740920451072 + QUAD $0xfc6f7c4045812296 // .quad -256850038250986858 + QUAD $0xf020000000000000 // .quad -1143914305352105984 + QUAD $0x9dc5ada82b70b59d // .quad -7078060301547948643 + QUAD $0x6c28000000000000 // .quad 7793479155164643328 + QUAD $0xc5371912364ce305 // .quad -4235889358507547899 + QUAD $0xc732000000000000 // .quad -4093209111326359552 + QUAD $0xf684df56c3e01bc6 // .quad -683175679707046970 + QUAD $0x3c7f400000000000 // .quad 4359273333062107136 + QUAD $0x9a130b963a6c115c // .quad -7344513827457986212 + QUAD $0x4b9f100000000000 // .quad 5449091666327633920 + QUAD $0xc097ce7bc90715b3 // .quad -4568956265895094861 + QUAD $0x1e86d40000000000 // .quad 2199678564482154496 + QUAD $0xf0bdc21abb48db20 // .quad -1099509313941480672 + QUAD $0x1314448000000000 // .quad 1374799102801346560 + QUAD $0x96769950b50d88f4 // .quad -7604722348854507276 + QUAD $0x17d955a000000000 // .quad 1718498878501683200 + QUAD $0xbc143fa4e250eb31 // .quad -4894216917640746191 + QUAD $0x5dcfab0800000000 // .quad 6759809616554491904 + QUAD $0xeb194f8e1ae525fd // .quad -1506085128623544835 + QUAD $0x5aa1cae500000000 // .quad 6530724019560251392 + QUAD $0x92efd1b8d0cf37be // .quad -7858832233030797378 + QUAD $0xf14a3d9e40000000 // .quad -1059967012404461568 + QUAD $0xb7abc627050305ad // .quad -5211854272861108819 + QUAD $0x6d9ccd05d0000000 // .quad 7898413271349198848 + QUAD $0xe596b7b0c643c719 // .quad -1903131822648998119 + QUAD $0xe4820023a2000000 // .quad -1981020733047832576 + QUAD $0x8f7e32ce7bea5c6f // .quad -8106986416796705681 + QUAD $0xdda2802c8a800000 // .quad -2476275916309790720 + QUAD $0xb35dbf821ae4f38b // .quad -5522047002568494197 + QUAD $0xd50b2037ad200000 // .quad -3095344895387238400 + QUAD $0xe0352f62a19e306e // .quad -2290872734783229842 + QUAD $0x4526f422cc340000 // .quad 4982938468024057856 + QUAD $0x8c213d9da502de45 // .quad -8349324486880600507 + QUAD $0x9670b12b7f410000 // .quad -7606384970252091392 + QUAD $0xaf298d050e4395d6 // .quad -5824969590173362730 + QUAD $0x3c0cdd765f114000 // .quad 4327076842467049472 + QUAD $0xdaf3f04651d47b4c // .quad -2669525969289315508 + QUAD $0xa5880a69fb6ac800 // .quad -6518949010312869888 + QUAD $0x88d8762bf324cd0f // .quad -8585982758446904049 + QUAD $0x8eea0d047a457a00 // .quad -8148686262891087360 + QUAD $0xab0e93b6efee0053 // .quad -6120792429631242157 + QUAD $0x72a4904598d6d880 // .quad 8260886245095692416 + QUAD $0xd5d238a4abe98068 // .quad -3039304518611664792 + QUAD $0x47a6da2b7f864750 // .quad 5163053903184807760 + QUAD $0x85a36366eb71f041 // .quad -8817094351773372351 + QUAD $0x999090b65f67d924 // .quad -7381240676301154012 + QUAD $0xa70c3c40a64e6c51 // .quad -6409681921289327535 + QUAD $0xfff4b4e3f741cf6d // .quad -3178808521666707 + QUAD $0xd0cf4b50cfe20765 // .quad -3400416383184271515 + QUAD $0xbff8f10e7a8921a4 // .quad -4613672773753429596 + QUAD $0x82818f1281ed449f // .quad -9042789267131251553 + QUAD $0xaff72d52192b6a0d // .quad -5767090967191786995 + QUAD $0xa321f2d7226895c7 // .quad -6691800565486676537 + QUAD $0x9bf4f8a69f764490 // .quad -7208863708989733744 + QUAD $0xcbea6f8ceb02bb39 // .quad -3753064688430957767 + QUAD $0x02f236d04753d5b4 // .quad 212292400617608628 + QUAD $0xfee50b7025c36a08 // .quad -79644842111309304 + QUAD $0x01d762422c946590 // .quad 132682750386005392 + QUAD $0x9f4f2726179a2245 // .quad -6967307053960650171 + QUAD $0x424d3ad2b7b97ef5 // .quad 4777539456409894645 + QUAD $0xc722f0ef9d80aad6 // .quad -4097447799023424810 + QUAD $0xd2e0898765a7deb2 // .quad -3251447716342407502 + QUAD $0xf8ebad2b84e0d58b // .quad -510123730351893109 + QUAD $0x63cc55f49f88eb2f // .quad 7191217214140771119 + QUAD $0x9b934c3b330c8577 // .quad -7236356359111015049 + QUAD $0x3cbf6b71c76b25fb // .quad 4377335499248575995 + QUAD $0xc2781f49ffcfa6d5 // .quad -4433759430461380907 + QUAD $0x8bef464e3945ef7a // .quad -8363388681221443718 + QUAD $0xf316271c7fc3908a // .quad -930513269649338230 + QUAD $0x97758bf0e3cbb5ac // .quad -7532960934977096276 + QUAD $0x97edd871cfda3a56 // .quad -7499099821171918250 + QUAD $0x3d52eeed1cbea317 // .quad 4418856886560793367 + QUAD $0xbde94e8e43d0c8ec // .quad -4762188758037509908 + QUAD $0x4ca7aaa863ee4bdd // .quad 5523571108200991709 + QUAD $0xed63a231d4c4fb27 // .quad -1341049929119499481 + QUAD $0x8fe8caa93e74ef6a // .quad -8076983103442849942 + QUAD $0x945e455f24fb1cf8 // .quad -7755685233340769032 + QUAD $0xb3e2fd538e122b44 // .quad -5484542860876174524 + QUAD $0xb975d6b6ee39e436 // .quad -5082920523248573386 + QUAD $0x60dbbca87196b616 // .quad 6979379479186945558 + QUAD $0xe7d34c64a9c85d44 // .quad -1741964635633328828 + QUAD $0xbc8955e946fe31cd // .quad -4861259862362934835 + QUAD $0x90e40fbeea1d3a4a // .quad -8006256924911912374 + QUAD $0x6babab6398bdbe41 // .quad 7758483227328495169 + QUAD $0xb51d13aea4a488dd // .quad -5396135137712502563 + QUAD $0xc696963c7eed2dd1 // .quad -4136954021121544751 + QUAD $0xe264589a4dcdab14 // .quad -2133482903713240300 + QUAD $0xfc1e1de5cf543ca2 // .quad -279753253987271518 + QUAD $0x8d7eb76070a08aec // .quad -8250955842461857044 + QUAD $0x3b25a55f43294bcb // .quad 4261994450943298507 + QUAD $0xb0de65388cc8ada8 // .quad -5702008784649933400 + QUAD $0x49ef0eb713f39ebe // .quad 5327493063679123134 + QUAD $0xdd15fe86affad912 // .quad -2515824962385028846 + QUAD $0x6e3569326c784337 // .quad 7941369183226839863 + QUAD $0x8a2dbf142dfcc7ab // .quad -8489919629131724885 + QUAD $0x49c2c37f07965404 // .quad 5315025460606161924 + QUAD $0xacb92ed9397bf996 // .quad -6000713517987268202 + QUAD $0xdc33745ec97be906 // .quad -2579590211097073402 + QUAD $0xd7e77a8f87daf7fb // .quad -2889205879056697349 + QUAD $0x69a028bb3ded71a3 // .quad 7611128154919104931 + QUAD $0x86f0ac99b4e8dafd // .quad -8723282702051517699 + QUAD $0xc40832ea0d68ce0c // .quad -4321147861633282548 + QUAD $0xa8acd7c0222311bc // .quad -6292417359137009220 + QUAD $0xf50a3fa490c30190 // .quad -789748808614215280 + QUAD $0xd2d80db02aabd62b // .quad -3253835680493873621 + QUAD $0x792667c6da79e0fa // .quad 8729779031470891258 + QUAD $0x83c7088e1aab65db // .quad -8951176327949752869 + QUAD $0x577001b891185938 // .quad 6300537770911226168 + QUAD $0xa4b8cab1a1563f52 // .quad -6577284391509803182 + QUAD $0xed4c0226b55e6f86 // .quad -1347699823215743098 + QUAD $0xcde6fd5e09abcf26 // .quad -3609919470959866074 + QUAD $0x544f8158315b05b4 // .quad 6075216638131242420 + QUAD $0x80b05e5ac60b6178 // .quad -9173728696990998152 + QUAD $0x696361ae3db1c721 // .quad 7594020797664053025 + QUAD $0xa0dc75f1778e39d6 // .quad -6855474852811359786 + QUAD $0x03bc3a19cd1e38e9 // .quad 269153960225290473 + QUAD $0xc913936dd571c84c // .quad -3957657547586811828 + QUAD $0x04ab48a04065c723 // .quad 336442450281613091 + QUAD $0xfb5878494ace3a5f // .quad -335385916056126881 + QUAD $0x62eb0d64283f9c76 // .quad 7127805559067090038 + QUAD $0x9d174b2dcec0e47b // .quad -7127145225176161157 + QUAD $0x3ba5d0bd324f8394 // .quad 4298070930406474644 + QUAD $0xc45d1df942711d9a // .quad -4297245513042813542 + QUAD $0xca8f44ec7ee36479 // .quad -3850783373846682503 + QUAD $0xf5746577930d6500 // .quad -759870872876129024 + QUAD $0x7e998b13cf4e1ecb // .quad 9122475437414293195 + QUAD $0x9968bf6abbe85f20 // .quad -7392448323188662496 + QUAD $0x9e3fedd8c321a67e // .quad -7043649776941685122 + QUAD $0xbfc2ef456ae276e8 // .quad -4628874385558440216 + QUAD $0xc5cfe94ef3ea101e // .quad -4192876202749718498 + QUAD $0xefb3ab16c59b14a2 // .quad -1174406963520662366 + QUAD $0xbba1f1d158724a12 // .quad -4926390635932268014 + QUAD $0x95d04aee3b80ece5 // .quad -7651533379841495835 + QUAD $0x2a8a6e45ae8edc97 // .quad 3065383741939440791 + QUAD $0xbb445da9ca61281f // .quad -4952730706374481889 + QUAD $0xf52d09d71a3293bd // .quad -779956341003086915 + QUAD $0xea1575143cf97226 // .quad -1579227364540714458 + QUAD $0x593c2626705f9c56 // .quad 6430056314514152534 + QUAD $0x924d692ca61be758 // .quad -7904546130479028392 + QUAD $0x6f8b2fb00c77836c // .quad 8037570393142690668 + QUAD $0xb6e0c377cfa2e12e // .quad -5268996644671397586 + QUAD $0x0b6dfb9c0f956447 // .quad 823590954573587527 + QUAD $0xe498f455c38b997a // .quad -1974559787411859078 + QUAD $0x4724bd4189bd5eac // .quad 5126430365035880108 + QUAD $0x8edf98b59a373fec // .quad -8151628894773493780 + QUAD $0x58edec91ec2cb657 // .quad 6408037956294850135 + QUAD $0xb2977ee300c50fe7 // .quad -5577850100039479321 + QUAD $0x2f2967b66737e3ed // .quad 3398361426941174765 + QUAD $0xdf3d5e9bc0f653e1 // .quad -2360626606621961247 + QUAD $0xbd79e0d20082ee74 // .quad -4793553135802847628 + QUAD $0x8b865b215899f46c // .quad -8392920656779807636 + QUAD $0xecd8590680a3aa11 // .quad -1380255401326171631 + QUAD $0xae67f1e9aec07187 // .quad -5879464802547371641 + QUAD $0xe80e6f4820cc9495 // .quad -1725319251657714539 + QUAD $0xda01ee641a708de9 // .quad -2737644984756826647 + QUAD $0x3109058d147fdcdd // .quad 3533361486141316317 + QUAD $0x884134fe908658b2 // .quad -8628557143114098510 + QUAD $0xbd4b46f0599fd415 // .quad -4806670179178130411 + QUAD $0xaa51823e34a7eede // .quad -6174010410465235234 + QUAD $0x6c9e18ac7007c91a // .quad 7826720331309500698 + QUAD $0xd4e5e2cdc1d1ea96 // .quad -3105826994654156138 + QUAD $0x03e2cf6bc604ddb0 // .quad 280014188641050032 + QUAD $0x850fadc09923329e // .quad -8858670899299929442 + QUAD $0x84db8346b786151c // .quad -8873354301053463268 + QUAD $0xa6539930bf6bff45 // .quad -6461652605697523899 + QUAD $0xe612641865679a63 // .quad -1868320839462053277 + QUAD $0xcfe87f7cef46ff16 // .quad -3465379738694516970 + QUAD $0x4fcb7e8f3f60c07e // .quad 5749828502977298558 + QUAD $0x81f14fae158c5f6e // .quad -9083391364325154962 + QUAD $0xe3be5e330f38f09d // .quad -2036086408133152611 + QUAD $0xa26da3999aef7749 // .quad -6742553186979055799 + QUAD $0x5cadf5bfd3072cc5 // .quad 6678264026688335045 + QUAD $0xcb090c8001ab551c // .quad -3816505465296431844 + QUAD $0x73d9732fc7c8f7f6 // .quad 8347830033360418806 + QUAD $0xfdcb4fa002162a63 // .quad -158945813193151901 + QUAD $0x2867e7fddcdd9afa // .quad 2911550761636567802 + QUAD $0x9e9f11c4014dda7e // .quad -7016870160886801794 + QUAD $0xb281e1fd541501b8 // .quad -5583933584809066056 + QUAD $0xc646d63501a1511d // .quad -4159401682681114339 + QUAD $0x1f225a7ca91a4226 // .quad 2243455055843443238 + QUAD $0xf7d88bc24209a565 // .quad -587566084924005019 + QUAD $0x3375788de9b06958 // .quad 3708002419115845976 + QUAD $0x9ae757596946075f // .quad -7284757830718584993 + QUAD $0x0052d6b1641c83ae // .quad 23317005467419566 + QUAD $0xc1a12d2fc3978937 // .quad -4494261269970843337 + QUAD $0xc0678c5dbd23a49a // .quad -4582539761593113446 + QUAD $0xf209787bb47d6b84 // .quad -1006140569036166268 + QUAD $0xf840b7ba963646e0 // .quad -558244341782001952 + QUAD $0x9745eb4d50ce6332 // .quad -7546366883288685774 + QUAD $0xb650e5a93bc3d898 // .quad -5309491445654890344 + QUAD $0xbd176620a501fbff // .quad -4821272585683469313 + QUAD $0xa3e51f138ab4cebe // .quad -6636864307068612930 + QUAD $0xec5d3fa8ce427aff // .quad -1414904713676948737 + QUAD $0xc66f336c36b10137 // .quad -4148040191917883081 + QUAD $0x93ba47c980e98cdf // .quad -7801844473689174817 + QUAD $0xb80b0047445d4184 // .quad -5185050239897353852 + QUAD $0xb8a8d9bbe123f017 // .quad -5140619573684080617 + QUAD $0xa60dc059157491e5 // .quad -6481312799871692315 + QUAD $0xe6d3102ad96cec1d // .quad -1814088448677712867 + QUAD $0x87c89837ad68db2f // .quad -8662506518347195601 + QUAD $0x9043ea1ac7e41392 // .quad -8051334308064652398 + QUAD $0x29babe4598c311fb // .quad 3006924907348169211 + QUAD $0xb454e4a179dd1877 // .quad -5452481866653427593 + QUAD $0xf4296dd6fef3d67a // .quad -853029884242176390 + QUAD $0xe16a1dc9d8545e94 // .quad -2203916314889396588 + QUAD $0x1899e4a65f58660c // .quad 1772699331562333708 + QUAD $0x8ce2529e2734bb1d // .quad -8294976724446954723 + QUAD $0x5ec05dcff72e7f8f // .quad 6827560182880305039 + QUAD $0xb01ae745b101e9e4 // .quad -5757034887131305500 + QUAD $0x76707543f4fa1f73 // .quad 8534450228600381299 + QUAD $0xdc21a1171d42645d // .quad -2584607590486743971 + QUAD $0x6a06494a791c53a8 // .quad 7639874402088932264 + QUAD $0x899504ae72497eba // .quad -8532908771695296838 + QUAD $0x0487db9d17636892 // .quad 326470965756389522 + QUAD $0xabfa45da0edbde69 // .quad -6054449946191733143 + QUAD $0x45a9d2845d3c42b6 // .quad 5019774725622874806 + QUAD $0xd6f8d7509292d603 // .quad -2956376414312278525 + QUAD $0x0b8a2392ba45a9b2 // .quad 831516194300602802 + QUAD $0x865b86925b9bc5c2 // .quad -8765264286586255934 + QUAD $0x8e6cac7768d7141e // .quad -8183976793979022306 + QUAD $0xa7f26836f282b732 // .quad -6344894339805432014 + QUAD $0x3207d795430cd926 // .quad 3605087062808385830 + QUAD $0xd1ef0244af2364ff // .quad -3319431906329402113 + QUAD $0x7f44e6bd49e807b8 // .quad 9170708441896323000 + QUAD $0x8335616aed761f1f // .quad -8992173969096958177 + QUAD $0x5f16206c9c6209a6 // .quad 6851699533943015846 + QUAD $0xa402b9c5a8d3a6e7 // .quad -6628531442943809817 + QUAD $0x36dba887c37a8c0f // .quad 3952938399001381903 + QUAD $0xcd036837130890a1 // .quad -3673978285252374367 + QUAD $0xc2494954da2c9789 // .quad -4446942528265218167 + QUAD $0x802221226be55a64 // .quad -9213765455923815836 + QUAD $0xf2db9baa10b7bd6c // .quad -946992141904134804 + QUAD $0xa02aa96b06deb0fd // .quad -6905520801477381891 + QUAD $0x6f92829494e5acc7 // .quad 8039631859474607303 + QUAD $0xc83553c5c8965d3d // .quad -4020214983419339459 + QUAD $0xcb772339ba1f17f9 // .quad -3785518230938904583 + QUAD $0xfa42a8b73abbf48c // .quad -413582710846786420 + QUAD $0xff2a760414536efb // .quad -60105885123121413 + QUAD $0x9c69a97284b578d7 // .quad -7176018221920323369 + QUAD $0xfef5138519684aba // .quad -75132356403901766 + QUAD $0xc38413cf25e2d70d // .quad -4358336758973016307 + QUAD $0x7eb258665fc25d69 // .quad 9129456591349898601 + QUAD $0xf46518c2ef5b8cd1 // .quad -836234930288882479 + QUAD $0xef2f773ffbd97a61 // .quad -1211618658047395231 + QUAD $0x98bf2f79d5993802 // .quad -7440175859071633406 + QUAD $0xaafb550ffacfd8fa // .quad -6126209340986631942 + QUAD $0xbeeefb584aff8603 // .quad -4688533805412153853 + QUAD $0x95ba2a53f983cf38 // .quad -7657761676233289928 + QUAD $0xeeaaba2e5dbf6784 // .quad -1248981238337804412 + QUAD $0xdd945a747bf26183 // .quad -2480258038432112253 + QUAD $0x952ab45cfa97a0b2 // .quad -7698142301602209614 + QUAD $0x94f971119aeef9e4 // .quad -7712008566467528220 + QUAD $0xba756174393d88df // .quad -5010991858575374113 + QUAD $0x7a37cd5601aab85d // .quad 8806733365625141341 + QUAD $0xe912b9d1478ceb17 // .quad -1652053804791829737 + QUAD $0xac62e055c10ab33a // .quad -6025006692552756422 + QUAD $0x91abb422ccb812ee // .quad -7950062655635975442 + QUAD $0x577b986b314d6009 // .quad 6303799689591218185 + QUAD $0xb616a12b7fe617aa // .quad -5325892301117581398 + QUAD $0xed5a7e85fda0b80b // .quad -1343622424865753077 + QUAD $0xe39c49765fdf9d94 // .quad -2045679357969588844 + QUAD $0x14588f13be847307 // .quad 1466078993672598279 + QUAD $0x8e41ade9fbebc27d // .quad -8196078626372074883 + QUAD $0x596eb2d8ae258fc8 // .quad 6444284760518135752 + QUAD $0xb1d219647ae6b31c // .quad -5633412264537705700 + QUAD $0x6fca5f8ed9aef3bb // .quad 8055355950647669691 + QUAD $0xde469fbd99a05fe3 // .quad -2430079312244744221 + QUAD $0x25de7bb9480d5854 // .quad 2728754459941099604 + QUAD $0x8aec23d680043bee // .quad -8436328597794046994 + QUAD $0xaf561aa79a10ae6a // .quad -5812428961928401302 + QUAD $0xada72ccc20054ae9 // .quad -5933724728815170839 + QUAD $0x1b2ba1518094da04 // .quad 1957835834444274180 + QUAD $0xd910f7ff28069da4 // .quad -2805469892591575644 + QUAD $0x90fb44d2f05d0842 // .quad -7999724640327104446 + QUAD $0x87aa9aff79042286 // .quad -8670947710510816634 + QUAD $0x353a1607ac744a53 // .quad 3835402254873283155 + QUAD $0xa99541bf57452b28 // .quad -6226998619711132888 + QUAD $0x42889b8997915ce8 // .quad 4794252818591603944 + QUAD $0xd3fa922f2d1675f2 // .quad -3172062256211528206 + QUAD $0x69956135febada11 // .quad 7608094030047140369 + QUAD $0x847c9b5d7c2e09b7 // .quad -8900067937773286985 + QUAD $0x43fab9837e699095 // .quad 4898431519131537557 + QUAD $0xa59bc234db398c25 // .quad -6513398903789220827 + QUAD $0x94f967e45e03f4bb // .quad -7712018656367741765 + QUAD $0xcf02b2c21207ef2e // .quad -3530062611309138130 + QUAD $0x1d1be0eebac278f5 // .quad 2097517367411243253 + QUAD $0x8161afb94b44f57d // .quad -9123818159709293187 + QUAD $0x6462d92a69731732 // .quad 7233582727691441970 + QUAD $0xa1ba1ba79e1632dc // .quad -6793086681209228580 + QUAD $0x7d7b8f7503cfdcfe // .quad 9041978409614302462 + QUAD $0xca28a291859bbf93 // .quad -3879672333084147821 + QUAD $0x5cda735244c3d43e // .quad 6690786993590490174 + QUAD $0xfcb2cb35e702af78 // .quad -237904397927796872 + QUAD $0x3a0888136afa64a7 // .quad 4181741870994056359 + QUAD $0x9defbf01b061adab // .quad -7066219276345954901 + QUAD $0x088aaa1845b8fdd0 // .quad 615491320315182544 + QUAD $0xc56baec21c7a1916 // .quad -4221088077005055722 + QUAD $0x8aad549e57273d45 // .quad -8454007886460797627 + QUAD $0xf6c69a72a3989f5b // .quad -664674077828931749 + QUAD $0x36ac54e2f678864b // .quad 3939617107816777291 + QUAD $0x9a3c2087a63f6399 // .quad -7332950326284164199 + QUAD $0x84576a1bb416a7dd // .quad -8910536670511192099 + QUAD $0xc0cb28a98fcf3c7f // .quad -4554501889427817345 + QUAD $0x656d44a2a11c51d5 // .quad 7308573235570561493 + QUAD $0xf0fdf2d3f3c30b9f // .quad -1081441343357383777 + QUAD $0x9f644ae5a4b1b325 // .quad -6961356773836868827 + QUAD $0x969eb7c47859e743 // .quad -7593429867239446717 + QUAD $0x873d5d9f0dde1fee // .quad -8701695967296086034 + QUAD $0xbc4665b596706114 // .quad -4880101315621920492 + QUAD $0xa90cb506d155a7ea // .quad -6265433940692719638 + QUAD $0xeb57ff22fc0c7959 // .quad -1488440626100012711 + QUAD $0x09a7f12442d588f2 // .quad 695789805494438130 + QUAD $0x9316ff75dd87cbd8 // .quad -7847804418953589800 + QUAD $0x0c11ed6d538aeb2f // .quad 869737256868047663 + QUAD $0xb7dcbf5354e9bece // .quad -5198069505264599346 + QUAD $0x8f1668c8a86da5fa // .quad -8136200465769716230 + QUAD $0xe5d3ef282a242e81 // .quad -1885900863153361279 + QUAD $0xf96e017d694487bc // .quad -473439272678684740 + QUAD $0x8fa475791a569d10 // .quad -8096217067111932656 + QUAD $0x37c981dcc395a9ac // .quad 4019886927579031980 + QUAD $0xb38d92d760ec4455 // .quad -5508585315462527915 + QUAD $0x85bbe253f47b1417 // .quad -8810199395808373737 + QUAD $0xe070f78d3927556a // .quad -2274045625900771990 + QUAD $0x93956d7478ccec8e // .quad -7812217631593927538 + QUAD $0x8c469ab843b89562 // .quad -8338807543829064350 + QUAD $0x387ac8d1970027b2 // .quad 4069786015789754290 + QUAD $0xaf58416654a6babb // .quad -5811823411358942533 + QUAD $0x06997b05fcc0319e // .quad 475546501309804958 + QUAD $0xdb2e51bfe9d0696a // .quad -2653093245771290262 + QUAD $0x441fece3bdf81f03 // .quad 4908902581746016003 + QUAD $0x88fcf317f22241e2 // .quad -8575712306248138270 + QUAD $0xd527e81cad7626c3 // .quad -3087243809672255805 + QUAD $0xab3c2fddeeaad25a // .quad -6107954364382784934 + QUAD $0x8a71e223d8d3b074 // .quad -8470740780517707660 + QUAD $0xd60b3bd56a5586f1 // .quad -3023256937051093263 + QUAD $0xf6872d5667844e49 // .quad -682526969396179383 + QUAD $0x85c7056562757456 // .quad -8807064613298015146 + QUAD $0xb428f8ac016561db // .quad -5464844730172612133 + QUAD $0xa738c6bebb12d16c // .quad -6397144748195131028 + QUAD $0xe13336d701beba52 // .quad -2219369894288377262 + QUAD $0xd106f86e69d785c7 // .quad -3384744916816525881 + QUAD $0xecc0024661173473 // .quad -1387106183930235789 + QUAD $0x82a45b450226b39c // .quad -9032994600651410532 + QUAD $0x27f002d7f95d0190 // .quad 2877803288514593168 + QUAD $0xa34d721642b06084 // .quad -6679557232386875260 + QUAD $0x31ec038df7b441f4 // .quad 3597254110643241460 + QUAD $0xcc20ce9bd35c78a5 // .quad -3737760522056206171 + QUAD $0x7e67047175a15271 // .quad 9108253656731439729 + QUAD $0xff290242c83396ce // .quad -60514634142869810 + QUAD $0x0f0062c6e984d386 // .quad 1080972517029761926 + QUAD $0x9f79a169bd203e41 // .quad -6955350673980375487 + QUAD $0x52c07b78a3e60868 // .quad 5962901664714590312 + QUAD $0xc75809c42c684dd1 // .quad -4082502324048081455 + QUAD $0xa7709a56ccdf8a82 // .quad -6381430974388925822 + QUAD $0xf92e0c3537826145 // .quad -491441886632713915 + QUAD $0x88a66076400bb691 // .quad -8600080377420466543 + QUAD $0x9bbcc7a142b17ccb // .quad -7224680206786528053 + QUAD $0x6acff893d00ea435 // .quad 7696643601933968437 + QUAD $0xc2abf989935ddbfe // .quad -4419164240055772162 + QUAD $0x0583f6b8c4124d43 // .quad 397432465562684739 + QUAD $0xf356f7ebf83552fe // .quad -912269281642327298 + QUAD $0xc3727a337a8b704a // .quad -4363290727450709942 + QUAD $0x98165af37b2153de // .quad -7487697328667536418 + QUAD $0x744f18c0592e4c5c // .quad 8380944645968776284 + QUAD $0xbe1bf1b059e9a8d6 // .quad -4747935642407032618 + QUAD $0x1162def06f79df73 // .quad 1252808770606194547 + QUAD $0xeda2ee1c7064130c // .quad -1323233534581402868 + QUAD $0x8addcb5645ac2ba8 // .quad -8440366555225904216 + QUAD $0x9485d4d1c63e8be7 // .quad -7744549986754458649 + QUAD $0x6d953e2bd7173692 // .quad 7896285879677171346 + QUAD $0xb9a74a0637ce2ee1 // .quad -5069001465015685407 + QUAD $0xc8fa8db6ccdd0437 // .quad -3964700705685699529 + QUAD $0xe8111c87c5c1ba99 // .quad -1724565812842218855 + QUAD $0x1d9c9892400a22a2 // .quad 2133748077373825698 + QUAD $0x910ab1d4db9914a0 // .quad -7995382660667468640 + QUAD $0x2503beb6d00cab4b // .quad 2667185096717282123 + QUAD $0xb54d5e4a127f59c8 // .quad -5382542307406947896 + QUAD $0x2e44ae64840fd61d // .quad 3333981370896602653 + QUAD $0xe2a0b5dc971f303a // .quad -2116491865831296966 + QUAD $0x5ceaecfed289e5d2 // .quad 6695424375237764562 + QUAD $0x8da471a9de737e24 // .quad -8240336443785642460 + QUAD $0x7425a83e872c5f47 // .quad 8369280469047205703 + QUAD $0xb10d8e1456105dad // .quad -5688734536304665171 + QUAD $0xd12f124e28f77719 // .quad -3373457468973156583 + QUAD $0xdd50f1996b947518 // .quad -2499232151953443560 + QUAD $0x82bd6b70d99aaa6f // .quad -9025939945749304721 + QUAD $0x8a5296ffe33cc92f // .quad -8479549122611984081 + QUAD $0x636cc64d1001550b // .quad 7164319141522920715 + QUAD $0xace73cbfdc0bfb7b // .quad -5987750384837592197 + QUAD $0x3c47f7e05401aa4e // .quad 4343712908476262990 + QUAD $0xd8210befd30efa5a // .quad -2873001962619602342 + QUAD $0x65acfaec34810a71 // .quad 7326506586225052273 + QUAD $0x8714a775e3e95c78 // .quad -8713155254278333320 + QUAD $0x7f1839a741a14d0d // .quad 9158133232781315341 + QUAD $0xa8d9d1535ce3b396 // .quad -6279758049420528746 + QUAD $0x1ede48111209a050 // .quad 2224294504121868368 + QUAD $0xd31045a8341ca07c // .quad -3238011543348273028 + QUAD $0x934aed0aab460432 // .quad -7833187971778608078 + QUAD $0x83ea2b892091e44d // .quad -8941286242233752499 + QUAD $0xf81da84d5617853f // .quad -568112927868484289 + QUAD $0xa4e4b66b68b65d60 // .quad -6564921784364802720 + QUAD $0x36251260ab9d668e // .quad 3901544858591782542 + QUAD $0xce1de40642e3f4b9 // .quad -3594466212028615495 + QUAD $0xc1d72b7c6b426019 // .quad -4479063491021217767 + QUAD $0x80d2ae83e9ce78f3 // .quad -9164070410158966541 + QUAD $0xb24cf65b8612f81f // .quad -5598829363776522209 + QUAD $0xa1075a24e4421730 // .quad -6843401994271320272 + QUAD $0xdee033f26797b627 // .quad -2386850686293264857 + QUAD $0xc94930ae1d529cfc // .quad -3942566474411762436 + QUAD $0x169840ef017da3b1 // .quad 1628122660560806833 + QUAD $0xfb9b7cd9a4a7443c // .quad -316522074587315140 + QUAD $0x8e1f289560ee864e // .quad -8205795374004271538 + QUAD $0x9d412e0806e88aa5 // .quad -7115355324258153819 + QUAD $0xf1a6f2bab92a27e2 // .quad -1033872180650563614 + QUAD $0xc491798a08a2ad4e // .quad -4282508136895304370 + QUAD $0xae10af696774b1db // .quad -5904026244240592421 + QUAD $0xf5b5d7ec8acb58a2 // .quad -741449152691742558 + QUAD $0xacca6da1e0a8ef29 // .quad -5995859411864064215 + QUAD $0x9991a6f3d6bf1765 // .quad -7380934748073420955 + QUAD $0x17fd090a58d32af3 // .quad 1728547772024695539 + QUAD $0xbff610b0cc6edd3f // .quad -4614482416664388289 + QUAD $0xddfc4b4cef07f5b0 // .quad -2451001303396518480 + QUAD $0xeff394dcff8a948e // .quad -1156417002403097458 + QUAD $0x4abdaf101564f98e // .quad 5385653213018257806 + QUAD $0x95f83d0a1fb69cd9 // .quad -7640289654143017767 + QUAD $0x9d6d1ad41abe37f1 // .quad -7102991539009341455 + QUAD $0xbb764c4ca7a4440f // .quad -4938676049251384305 + QUAD $0x84c86189216dc5ed // .quad -8878739423761676819 + QUAD $0xea53df5fd18d5513 // .quad -1561659043136842477 + QUAD $0x32fd3cf5b4e49bb4 // .quad 3674159897003727796 + QUAD $0x92746b9be2f8552c // .quad -7893565929601608404 + QUAD $0x3fbc8c33221dc2a1 // .quad 4592699871254659745 + QUAD $0xb7118682dbb66a77 // .quad -5255271393574622601 + QUAD $0x0fabaf3feaa5334a // .quad 1129188820640936778 + QUAD $0xe4d5e82392a40515 // .quad -1957403223540890347 + QUAD $0x29cb4d87f2a7400e // .quad 3011586022114279438 + QUAD $0x8f05b1163ba6832d // .quad -8140906042354138323 + QUAD $0x743e20e9ef511012 // .quad 8376168546070237202 + QUAD $0xb2c71d5bca9023f8 // .quad -5564446534515285000 + QUAD $0x914da9246b255416 // .quad -7976533391121755114 + QUAD $0xdf78e4b2bd342cf6 // .quad -2343872149716718346 + QUAD $0x1ad089b6c2f7548e // .quad 1932195658189984910 + QUAD $0x8bab8eefb6409c1a // .quad -8382449121214030822 + QUAD $0xa184ac2473b529b1 // .quad -6808127464117294671 + QUAD $0xae9672aba3d0c320 // .quad -5866375383090150624 + QUAD $0xc9e5d72d90a2741e // .quad -3898473311719230434 + QUAD $0xda3c0f568cc4f3e8 // .quad -2721283210435300376 + QUAD $0x7e2fa67c7a658892 // .quad 9092669226243950738 + QUAD $0x8865899617fb1871 // .quad -8618331034163144591 + QUAD $0xddbb901b98feeab7 // .quad -2469221522477225289 + QUAD $0xaa7eebfb9df9de8d // .quad -6161227774276542835 + QUAD $0x552a74227f3ea565 // .quad 6136845133758244197 + QUAD $0xd51ea6fa85785631 // .quad -3089848699418290639 + QUAD $0xd53a88958f87275f // .quad -3082000819042179233 + QUAD $0x8533285c936b35de // .quad -8848684464777513506 + QUAD $0x8a892abaf368f137 // .quad -8464187042230111945 + QUAD $0xa67ff273b8460356 // .quad -6449169562544503978 + QUAD $0x2d2b7569b0432d85 // .quad 3254824252494523781 + QUAD $0xd01fef10a657842c // .quad -3449775934753242068 + QUAD $0x9c3b29620e29fc73 // .quad -7189106879045698445 + QUAD $0x8213f56a67f6b29b // .quad -9073638986861858149 + QUAD $0x8349f3ba91b47b8f // .quad -8986383598807123057 + QUAD $0xa298f2c501f45f42 // .quad -6730362715149934782 + QUAD $0x241c70a936219a73 // .quad 2602078556773259891 + QUAD $0xcb3f2f7642717713 // .quad -3801267375510030573 + QUAD $0xed238cd383aa0110 // .quad -1359087822460813040 + QUAD $0xfe0efb53d30dd4d7 // .quad -139898200960150313 + QUAD $0xf4363804324a40aa // .quad -849429889038008150 + QUAD $0x9ec95d1463e8a506 // .quad -7004965403241175802 + QUAD $0xb143c6053edcd0d5 // .quad -5673473379724898091 + QUAD $0xc67bb4597ce2ce48 // .quad -4144520735624081848 + QUAD $0xdd94b7868e94050a // .quad -2480155706228734710 + QUAD $0xf81aa16fdc1b81da // .quad -568964901102714406 + QUAD $0xca7cf2b4191c8326 // .quad -3855940325606653146 + QUAD $0x9b10a4e5e9913128 // .quad -7273132090830278360 + QUAD $0xfd1c2f611f63a3f0 // .quad -208239388580928528 + QUAD $0xc1d4ce1f63f57d72 // .quad -4479729095110460046 + QUAD $0xbc633b39673c8cec // .quad -4871985254153548564 + QUAD $0xf24a01a73cf2dccf // .quad -987975350460687153 + QUAD $0xd5be0503e085d813 // .quad -3044990783845967853 + QUAD $0x976e41088617ca01 // .quad -7535013621679011327 + QUAD $0x4b2d8644d8a74e18 // .quad 5417133557047315992 + QUAD $0xbd49d14aa79dbc82 // .quad -4807081008671376254 + QUAD $0xddf8e7d60ed1219e // .quad -2451955090545630818 + QUAD $0xec9c459d51852ba2 // .quad -1397165242411832414 + QUAD $0xcabb90e5c942b503 // .quad -3838314940804713213 + QUAD $0x93e1ab8252f33b45 // .quad -7790757304148477115 + QUAD $0x3d6a751f3b936243 // .quad 4425478360848884291 + QUAD $0xb8da1662e7b00a17 // .quad -5126760611758208489 + QUAD $0x0cc512670a783ad4 // .quad 920161932633717460 + QUAD $0xe7109bfba19c0c9d // .quad -1796764746270372707 + QUAD $0x27fb2b80668b24c5 // .quad 2880944217109767365 + QUAD $0x906a617d450187e2 // .quad -8040506994060064798 + QUAD $0xb1f9f660802dedf6 // .quad -5622191765467566602 + QUAD $0xb484f9dc9641e9da // .quad -5438947724147693094 + QUAD $0x5e7873f8a0396973 // .quad 6807318348447705459 + QUAD $0xe1a63853bbd26451 // .quad -2186998636757228463 + QUAD $0xdb0b487b6423e1e8 // .quad -2662955059861265944 + QUAD $0x8d07e33455637eb2 // .quad -8284403175614349646 + QUAD $0x91ce1a9a3d2cda62 // .quad -7940379843253970334 + QUAD $0xb049dc016abc5e5f // .quad -5743817951090549153 + QUAD $0x7641a140cc7810fb // .quad 8521269269642088699 + QUAD $0xdc5c5301c56b75f7 // .quad -2568086420435798537 + QUAD $0xa9e904c87fcb0a9d // .quad -6203421752542164323 + QUAD $0x89b9b3e11b6329ba // .quad -8522583040413455942 + QUAD $0x546345fa9fbdcd44 // .quad 6080780864604458308 + QUAD $0xac2820d9623bf429 // .quad -6041542782089432023 + QUAD $0xa97c177947ad4095 // .quad -6234081974526590827 + QUAD $0xd732290fbacaf133 // .quad -2940242459184402125 + QUAD $0x49ed8eabcccc485d // .quad 5327070802775656541 + QUAD $0x867f59a9d4bed6c0 // .quad -8755180564631333184 + QUAD $0x5c68f256bfff5a74 // .quad 6658838503469570676 + QUAD $0xa81f301449ee8c70 // .quad -6332289687361778576 + QUAD $0x73832eec6fff3111 // .quad 8323548129336963345 + QUAD $0xd226fc195c6a2f8c // .quad -3303676090774835316 + QUAD $0xc831fd53c5ff7eab // .quad -4021154456019173717 + QUAD $0x83585d8fd9c25db7 // .quad -8982326584375353929 + QUAD $0xba3e7ca8b77f5e55 // .quad -5026443070023967147 + QUAD $0xa42e74f3d032f525 // .quad -6616222212041804507 + QUAD $0x28ce1bd2e55f35eb // .quad 2940318199324816875 + QUAD $0xcd3a1230c43fb26f // .quad -3658591746624867729 + QUAD $0x7980d163cf5b81b3 // .quad 8755227902219092403 + QUAD $0x80444b5e7aa7cf85 // .quad -9204148869281624187 + QUAD $0xd7e105bcc332621f // .quad -2891023177508298209 + QUAD $0xa0555e361951c366 // .quad -6893500068174642330 + QUAD $0x8dd9472bf3fefaa7 // .quad -8225464990312760665 + QUAD $0xc86ab5c39fa63440 // .quad -4005189066790915008 + QUAD $0xb14f98f6f0feb951 // .quad -5670145219463562927 + QUAD $0xfa856334878fc150 // .quad -394800315061255856 + QUAD $0x6ed1bf9a569f33d3 // .quad 7985374283903742931 + QUAD $0x9c935e00d4b9d8d2 // .quad -7164279224554366766 + QUAD $0x0a862f80ec4700c8 // .quad 758345818024902856 + QUAD $0xc3b8358109e84f07 // .quad -4343663012265570553 + QUAD $0xcd27bb612758c0fa // .quad -3663753745896259334 + QUAD $0xf4a642e14c6262c8 // .quad -817892746904575288 + QUAD $0x8038d51cb897789c // .quad -9207375118826243940 + QUAD $0x98e7e9cccfbd7dbd // .quad -7428711994456441411 + QUAD $0xe0470a63e6bd56c3 // .quad -2285846861678029117 + QUAD $0xbf21e44003acdd2c // .quad -4674203974643163860 + QUAD $0x1858ccfce06cac74 // .quad 1754377441329851508 + QUAD $0xeeea5d5004981478 // .quad -1231068949876566920 + QUAD $0x0f37801e0c43ebc8 // .quad 1096485900831157192 + QUAD $0x95527a5202df0ccb // .quad -7686947121313936181 + QUAD $0xd30560258f54e6ba // .quad -3241078642388441414 + QUAD $0xbaa718e68396cffd // .quad -4996997883215032323 + QUAD $0x47c6b82ef32a2069 // .quad 5172023733869224041 + QUAD $0xe950df20247c83fd // .quad -1634561335591402499 + QUAD $0x4cdc331d57fa5441 // .quad 5538357842881958977 + QUAD $0x91d28b7416cdd27e // .quad -7939129862385708418 + QUAD $0xe0133fe4adf8e952 // .quad -2300424733252327086 + QUAD $0xb6472e511c81471d // .quad -5312226309554747619 + QUAD $0x58180fddd97723a6 // .quad 6347841120289366950 + QUAD $0xe3d8f9e563a198e5 // .quad -2028596868516046619 + QUAD $0x570f09eaa7ea7648 // .quad 6273243709394548296 + QUAD $0x8e679c2f5e44ff8f // .quad -8185402070463610993 + QUAD $0x2cd2cc6551e513da // .quad 3229868618315797466 + QUAD $0xb201833b35d63f73 // .quad -5620066569652125837 + QUAD $0xf8077f7ea65e58d1 // .quad -574350245532641071 + QUAD $0xde81e40a034bcf4f // .quad -2413397193637769393 + QUAD $0xfb04afaf27faf782 // .quad -358968903457900670 + QUAD $0x8b112e86420f6191 // .quad -8425902273664687727 + QUAD $0x79c5db9af1f9b563 // .quad 8774660907532399971 + QUAD $0xadd57a27d29339f6 // .quad -5920691823653471754 + QUAD $0x18375281ae7822bc // .quad 1744954097560724156 + QUAD $0xd94ad8b1c7380874 // .quad -2789178761139451788 + QUAD $0x8f2293910d0b15b5 // .quad -8132775725879323211 + QUAD $0x87cec76f1c830548 // .quad -8660765753353239224 + QUAD $0xb2eb3875504ddb22 // .quad -5554283638921766110 + QUAD $0xa9c2794ae3a3c69a // .quad -6214271173264161126 + QUAD $0x5fa60692a46151eb // .quad 6892203506629956075 + QUAD $0xd433179d9c8cb841 // .quad -3156152948152813503 + QUAD $0xdbc7c41ba6bcd333 // .quad -2609901835997359309 + QUAD $0x849feec281d7f328 // .quad -8890124620236590296 + QUAD $0x12b9b522906c0800 // .quad 1349308723430688768 + QUAD $0xa5c7ea73224deff3 // .quad -6500969756868349965 + QUAD $0xd768226b34870a00 // .quad -2925050114139026944 + QUAD $0xcf39e50feae16bef // .quad -3514526177658049553 + QUAD $0xe6a1158300d46640 // .quad -1828156321336891840 + QUAD $0x81842f29f2cce375 // .quad -9114107888677362827 + QUAD $0x60495ae3c1097fd0 // .quad 6938176635183661008 + QUAD $0xa1e53af46f801c53 // .quad -6780948842419315629 + QUAD $0x385bb19cb14bdfc4 // .quad 4061034775552188356 + QUAD $0xca5e89b18b602368 // .quad -3864500034596756632 + QUAD $0x46729e03dd9ed7b5 // .quad 5076293469440235445 + QUAD $0xfcf62c1dee382c42 // .quad -218939024818557886 + QUAD $0x6c07a2c26a8346d1 // .quad 7784369436827535057 + QUAD $0x9e19db92b4e31ba9 // .quad -7054365918152680535 + QUAD $0xc7098b7305241885 // .quad -4104596259247744891 + QUAD $0xc5a05277621be293 // .quad -4206271379263462765 + QUAD $0xb8cbee4fc66d1ea7 // .quad -5130745324059681113 + QUAD $0xf70867153aa2db38 // .quad -646153205651940552 + QUAD $0x737f74f1dc043328 // .quad 8322499218531169064 + QUAD $0x9a65406d44a5c903 // .quad -7321374781173544701 + QUAD $0x505f522e53053ff2 // .quad 5791438004736573426 + QUAD $0xc0fe908895cf3b44 // .quad -4540032458039542972 + QUAD $0x647726b9e7c68fef // .quad 7239297505920716783 + QUAD $0xf13e34aabb430a15 // .quad -1063354554122040811 + QUAD $0x5eca783430dc19f5 // .quad 6830403950414141941 + QUAD $0x96c6e0eab509e64d // .quad -7582125623967357363 + QUAD $0xb67d16413d132072 // .quad -5297053117264486286 + QUAD $0xbc789925624c5fe0 // .quad -4865971011531808800 + QUAD $0xe41c5bd18c57e88f // .quad -2009630378153219953 + QUAD $0xeb96bf6ebadf77d8 // .quad -1470777745987373096 + QUAD $0x8e91b962f7b6f159 // .quad -8173548013986844327 + QUAD $0x933e37a534cbaae7 // .quad -7836765118883190041 + QUAD $0x723627bbb5a4adb0 // .quad 8229809056225996208 + QUAD $0xb80dc58e81fe95a1 // .quad -5184270380176599647 + QUAD $0xcec3b1aaa30dd91c // .quad -3547796734999668452 + QUAD $0xe61136f2227e3b09 // .quad -1868651956793361655 + QUAD $0x213a4f0aa5e8a7b1 // .quad 2394313059052595121 + QUAD $0x8fcac257558ee4e6 // .quad -8085436500636932890 + QUAD $0xa988e2cd4f62d19d // .quad -6230480713039031907 + QUAD $0xb3bd72ed2af29e1f // .quad -5495109607368778209 + QUAD $0x93eb1b80a33b8605 // .quad -7788100891298789883 + QUAD $0xe0accfa875af45a7 // .quad -2257200990783584857 + QUAD $0xbc72f130660533c3 // .quad -4867563057061743677 + QUAD $0x8c6c01c9498d8b88 // .quad -8328279646880822392 + QUAD $0xeb8fad7c7f8680b4 // .quad -1472767802899791692 + QUAD $0xaf87023b9bf0ee6a // .quad -5798663540173640086 + QUAD $0xa67398db9f6820e1 // .quad -6452645772052127519 + QUAD $0xdb68c2ca82ed2a05 // .quad -2636643406789662203 + QUAD $0x88083f8943a1148c // .quad -8644589625959967604 + QUAD $0x892179be91d43a43 // .quad -8565431156884620733 + QUAD $0x6a0a4f6b948959b0 // .quad 7641007041259592112 + QUAD $0xab69d82e364948d4 // .quad -6095102927678388012 + QUAD $0x848ce34679abb01c // .quad -8895485272135061476 + QUAD $0xd6444e39c3db9b09 // .quad -3007192641170597111 + QUAD $0xf2d80e0c0c0b4e11 // .quad -947992276657025519 + QUAD $0x85eab0e41a6940e5 // .quad -8797024428372705051 + QUAD $0x6f8e118f0f0e2195 // .quad 8038381691033493909 + QUAD $0xa7655d1d2103911f // .quad -6384594517038493409 + QUAD $0x4b7195f2d2d1a9fb // .quad 5436291095364479483 + QUAD $0xd13eb46469447567 // .quad -3369057127870728857 + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +_POW_TAB: + LONG $0x00000001 // .long 1 + LONG $0x00000003 // .long 3 + LONG $0x00000006 // .long 6 + LONG $0x00000009 // .long 9 + LONG $0x0000000d // .long 13 + LONG $0x00000010 // .long 16 + LONG $0x00000013 // .long 19 + LONG $0x00000017 // .long 23 + LONG $0x0000001a // .long 26 + + // .p2align 2, 0x00 +_MASK_USE_NUMBER: + LONG $0x00000002 // .long 2 + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_Digits: + QUAD $0x3330323031303030; QUAD $0x3730363035303430 // .ascii 16, '0001020304050607' + QUAD $0x3131303139303830; QUAD $0x3531343133313231 // .ascii 16, '0809101112131415' + QUAD $0x3931383137313631; QUAD $0x3332323231323032 // .ascii 16, '1617181920212223' + QUAD $0x3732363235323432; QUAD $0x3133303339323832 // .ascii 16, '2425262728293031' + QUAD $0x3533343333333233; QUAD $0x3933383337333633 // .ascii 16, '3233343536373839' + QUAD $0x3334323431343034; QUAD $0x3734363435343434 // .ascii 16, '4041424344454647' + QUAD $0x3135303539343834; QUAD $0x3535343533353235 // .ascii 16, '4849505152535455' + QUAD $0x3935383537353635; QUAD $0x3336323631363036 // .ascii 16, '5657585960616263' + QUAD $0x3736363635363436; QUAD $0x3137303739363836 // .ascii 16, '6465666768697071' + QUAD $0x3537343733373237; QUAD $0x3937383737373637 // .ascii 16, '7273747576777879' + QUAD $0x3338323831383038; QUAD $0x3738363835383438 // .ascii 16, '8081828384858687' + QUAD $0x3139303939383838; QUAD $0x3539343933393239 // .ascii 16, '8889909192939495' + QUAD $0x3939383937393639 // .ascii 8, '96979899' + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_LB_cf971573: // _pow10_ceil_sig.g + QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721 + QUAD $0x25e8e89c13bb0f7b // .quad 2731688931043774331 + QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807 + QUAD $0x77b191618c54e9ad // .quad 8624834609543440813 + QUAD $0xc795830d75038c1d // .quad -4065198994811024355 + QUAD $0xd59df5b9ef6a2418 // .quad -3054014793352862696 + QUAD $0xf97ae3d0d2446f25 // .quad -469812725086392539 + QUAD $0x4b0573286b44ad1e // .quad 5405853545163697438 + QUAD $0x9becce62836ac577 // .quad -7211161980820077193 + QUAD $0x4ee367f9430aec33 // .quad 5684501474941004851 + QUAD $0xc2e801fb244576d5 // .quad -4402266457597708587 + QUAD $0x229c41f793cda740 // .quad 2493940825248868160 + QUAD $0xf3a20279ed56d48a // .quad -891147053569747830 + QUAD $0x6b43527578c11110 // .quad 7729112049988473104 + QUAD $0x9845418c345644d6 // .quad -7474495936122174250 + QUAD $0x830a13896b78aaaa // .quad -9004363024039368022 + QUAD $0xbe5691ef416bd60c // .quad -4731433901725329908 + QUAD $0x23cc986bc656d554 // .quad 2579604275232953684 + QUAD $0xedec366b11c6cb8f // .quad -1302606358729274481 + QUAD $0x2cbfbe86b7ec8aa9 // .quad 3224505344041192105 + QUAD $0x94b3a202eb1c3f39 // .quad -7731658001846878407 + QUAD $0x7bf7d71432f3d6aa // .quad 8932844867666826922 + QUAD $0xb9e08a83a5e34f07 // .quad -5052886483881210105 + QUAD $0xdaf5ccd93fb0cc54 // .quad -2669001970698630060 + QUAD $0xe858ad248f5c22c9 // .quad -1704422086424124727 + QUAD $0xd1b3400f8f9cff69 // .quad -3336252463373287575 + QUAD $0x91376c36d99995be // .quad -7982792831656159810 + QUAD $0x23100809b9c21fa2 // .quad 2526528228819083170 + QUAD $0xb58547448ffffb2d // .quad -5366805021142811859 + QUAD $0xabd40a0c2832a78b // .quad -6065211750830921845 + QUAD $0xe2e69915b3fff9f9 // .quad -2096820258001126919 + QUAD $0x16c90c8f323f516d // .quad 1641857348316123501 + QUAD $0x8dd01fad907ffc3b // .quad -8228041688891786181 + QUAD $0xae3da7d97f6792e4 // .quad -5891368184943504668 + QUAD $0xb1442798f49ffb4a // .quad -5673366092687344822 + QUAD $0x99cd11cfdf41779d // .quad -7364210231179380835 + QUAD $0xdd95317f31c7fa1d // .quad -2480021597431793123 + QUAD $0x40405643d711d584 // .quad 4629795266307937668 + QUAD $0x8a7d3eef7f1cfc52 // .quad -8467542526035952558 + QUAD $0x482835ea666b2573 // .quad 5199465050656154995 + QUAD $0xad1c8eab5ee43b66 // .quad -5972742139117552794 + QUAD $0xda3243650005eed0 // .quad -2724040723534582064 + QUAD $0xd863b256369d4a40 // .quad -2854241655469553088 + QUAD $0x90bed43e40076a83 // .quad -8016736922845615485 + QUAD $0x873e4f75e2224e68 // .quad -8701430062309552536 + QUAD $0x5a7744a6e804a292 // .quad 6518754469289960082 + QUAD $0xa90de3535aaae202 // .quad -6265101559459552766 + QUAD $0x711515d0a205cb37 // .quad 8148443086612450103 + QUAD $0xd3515c2831559a83 // .quad -3219690930897053053 + QUAD $0x0d5a5b44ca873e04 // .quad 962181821410786820 + QUAD $0x8412d9991ed58091 // .quad -8929835859451740015 + QUAD $0xe858790afe9486c3 // .quad -1704479370831952189 + QUAD $0xa5178fff668ae0b6 // .quad -6550608805887287114 + QUAD $0x626e974dbe39a873 // .quad 7092772823314835571 + QUAD $0xce5d73ff402d98e3 // .quad -3576574988931720989 + QUAD $0xfb0a3d212dc81290 // .quad -357406007711231344 + QUAD $0x80fa687f881c7f8e // .quad -9152888395723407474 + QUAD $0x7ce66634bc9d0b9a // .quad 8999993282035256218 + QUAD $0xa139029f6a239f72 // .quad -6829424476226871438 + QUAD $0x1c1fffc1ebc44e81 // .quad 2026619565689294465 + QUAD $0xc987434744ac874e // .quad -3925094576856201394 + QUAD $0xa327ffb266b56221 // .quad -6690097579743157727 + QUAD $0xfbe9141915d7a922 // .quad -294682202642863838 + QUAD $0x4bf1ff9f0062baa9 // .quad 5472436080603216553 + QUAD $0x9d71ac8fada6c9b5 // .quad -7101705404292871755 + QUAD $0x6f773fc3603db4aa // .quad 8031958568804398250 + QUAD $0xc4ce17b399107c22 // .quad -4265445736938701790 + QUAD $0xcb550fb4384d21d4 // .quad -3795109844276665900 + QUAD $0xf6019da07f549b2b // .quad -720121152745989333 + QUAD $0x7e2a53a146606a49 // .quad 9091170749936331337 + QUAD $0x99c102844f94e0fb // .quad -7367604748107325189 + QUAD $0x2eda7444cbfc426e // .quad 3376138709496513134 + QUAD $0xc0314325637a1939 // .quad -4597819916706768583 + QUAD $0xfa911155fefb5309 // .quad -391512631556746487 + QUAD $0xf03d93eebc589f88 // .quad -1135588877456072824 + QUAD $0x793555ab7eba27cb // .quad 8733981247408842699 + QUAD $0x96267c7535b763b5 // .quad -7627272076051127371 + QUAD $0x4bc1558b2f3458df // .quad 5458738279630526687 + QUAD $0xbbb01b9283253ca2 // .quad -4922404076636521310 + QUAD $0x9eb1aaedfb016f17 // .quad -7011635205744005353 + QUAD $0xea9c227723ee8bcb // .quad -1541319077368263733 + QUAD $0x465e15a979c1cadd // .quad 5070514048102157021 + QUAD $0x92a1958a7675175f // .quad -7880853450996246689 + QUAD $0x0bfacd89ec191eca // .quad 863228270850154186 + QUAD $0xb749faed14125d36 // .quad -5239380795317920458 + QUAD $0xcef980ec671f667c // .quad -3532650679864695172 + QUAD $0xe51c79a85916f484 // .quad -1937539975720012668 + QUAD $0x82b7e12780e7401b // .quad -9027499368258256869 + QUAD $0x8f31cc0937ae58d2 // .quad -8128491512466089774 + QUAD $0xd1b2ecb8b0908811 // .quad -3336344095947716591 + QUAD $0xb2fe3f0b8599ef07 // .quad -5548928372155224313 + QUAD $0x861fa7e6dcb4aa16 // .quad -8782116138362033642 + QUAD $0xdfbdcece67006ac9 // .quad -2324474446766642487 + QUAD $0x67a791e093e1d49b // .quad 7469098900757009563 + QUAD $0x8bd6a141006042bd // .quad -8370325556870233411 + QUAD $0xe0c8bb2c5c6d24e1 // .quad -2249342214667950879 + QUAD $0xaecc49914078536d // .quad -5851220927660403859 + QUAD $0x58fae9f773886e19 // .quad 6411694268519837209 + QUAD $0xda7f5bf590966848 // .quad -2702340141148116920 + QUAD $0xaf39a475506a899f // .quad -5820440219632367201 + QUAD $0x888f99797a5e012d // .quad -8606491615858654931 + QUAD $0x6d8406c952429604 // .quad 7891439908798240260 + QUAD $0xaab37fd7d8f58178 // .quad -6146428501395930760 + QUAD $0xc8e5087ba6d33b84 // .quad -3970758169284363388 + QUAD $0xd5605fcdcf32e1d6 // .quad -3071349608317525546 + QUAD $0xfb1e4a9a90880a65 // .quad -351761693178066331 + QUAD $0x855c3be0a17fcd26 // .quad -8837122532839535322 + QUAD $0x5cf2eea09a550680 // .quad 6697677969404790400 + QUAD $0xa6b34ad8c9dfc06f // .quad -6434717147622031249 + QUAD $0xf42faa48c0ea481f // .quad -851274575098787809 + QUAD $0xd0601d8efc57b08b // .quad -3431710416100151157 + QUAD $0xf13b94daf124da27 // .quad -1064093218873484761 + QUAD $0x823c12795db6ce57 // .quad -9062348037703676329 + QUAD $0x76c53d08d6b70859 // .quad 8558313775058847833 + QUAD $0xa2cb1717b52481ed // .quad -6716249028702207507 + QUAD $0x54768c4b0c64ca6f // .quad 6086206200396171887 + QUAD $0xcb7ddcdda26da268 // .quad -3783625267450371480 + QUAD $0xa9942f5dcf7dfd0a // .quad -6227300304786948854 + QUAD $0xfe5d54150b090b02 // .quad -117845565885576446 + QUAD $0xd3f93b35435d7c4d // .quad -3172439362556298163 + QUAD $0x9efa548d26e5a6e1 // .quad -6991182506319567135 + QUAD $0xc47bc5014a1a6db0 // .quad -4288617610811380304 + QUAD $0xc6b8e9b0709f109a // .quad -4127292114472071014 + QUAD $0x359ab6419ca1091c // .quad 3862600023340550428 + QUAD $0xf867241c8cc6d4c0 // .quad -547429124662700864 + QUAD $0xc30163d203c94b63 // .quad -4395122007679087773 + QUAD $0x9b407691d7fc44f8 // .quad -7259672230555269896 + QUAD $0x79e0de63425dcf1e // .quad 8782263791269039902 + QUAD $0xc21094364dfb5636 // .quad -4462904269766699466 + QUAD $0x985915fc12f542e5 // .quad -7468914334623251739 + QUAD $0xf294b943e17a2bc4 // .quad -966944318780986428 + QUAD $0x3e6f5b7b17b2939e // .quad 4498915137003099038 + QUAD $0x979cf3ca6cec5b5a // .quad -7521869226879198374 + QUAD $0xa705992ceecf9c43 // .quad -6411550076227838909 + QUAD $0xbd8430bd08277231 // .quad -4790650515171610063 + QUAD $0x50c6ff782a838354 // .quad 5820620459997365076 + QUAD $0xece53cec4a314ebd // .quad -1376627125537124675 + QUAD $0xa4f8bf5635246429 // .quad -6559282480285457367 + QUAD $0x940f4613ae5ed136 // .quad -7777920981101784778 + QUAD $0x871b7795e136be9a // .quad -8711237568605798758 + QUAD $0xb913179899f68584 // .quad -5110715207949843068 + QUAD $0x28e2557b59846e40 // .quad 2946011094524915264 + QUAD $0xe757dd7ec07426e5 // .quad -1776707991509915931 + QUAD $0x331aeada2fe589d0 // .quad 3682513868156144080 + QUAD $0x9096ea6f3848984f // .quad -8027971522334779313 + QUAD $0x3ff0d2c85def7622 // .quad 4607414176811284002 + QUAD $0xb4bca50b065abe63 // .quad -5423278384491086237 + QUAD $0x0fed077a756b53aa // .quad 1147581702586717098 + QUAD $0xe1ebce4dc7f16dfb // .quad -2167411962186469893 + QUAD $0xd3e8495912c62895 // .quad -3177208890193991531 + QUAD $0x8d3360f09cf6e4bd // .quad -8272161504007625539 + QUAD $0x64712dd7abbbd95d // .quad 7237616480483531101 + QUAD $0xb080392cc4349dec // .quad -5728515861582144020 + QUAD $0xbd8d794d96aacfb4 // .quad -4788037454677749836 + QUAD $0xdca04777f541c567 // .quad -2548958808550292121 + QUAD $0xecf0d7a0fc5583a1 // .quad -1373360799919799391 + QUAD $0x89e42caaf9491b60 // .quad -8510628282985014432 + QUAD $0xf41686c49db57245 // .quad -858350499949874619 + QUAD $0xac5d37d5b79b6239 // .quad -6026599335303880135 + QUAD $0x311c2875c522ced6 // .quad 3538747893490044630 + QUAD $0xd77485cb25823ac7 // .quad -2921563150702462265 + QUAD $0x7d633293366b828c // .quad 9035120885289943692 + QUAD $0x86a8d39ef77164bc // .quad -8743505996830120772 + QUAD $0xae5dff9c02033198 // .quad -5882264492762254952 + QUAD $0xa8530886b54dbdeb // .quad -6317696477610263061 + QUAD $0xd9f57f830283fdfd // .quad -2741144597525430787 + QUAD $0xd267caa862a12d66 // .quad -3285434578585440922 + QUAD $0xd072df63c324fd7c // .quad -3426430746906788484 + QUAD $0x8380dea93da4bc60 // .quad -8970925639256982432 + QUAD $0x4247cb9e59f71e6e // .quad 4776009810824339054 + QUAD $0xa46116538d0deb78 // .quad -6601971030643840136 + QUAD $0x52d9be85f074e609 // .quad 5970012263530423817 + QUAD $0xcd795be870516656 // .quad -3640777769877412266 + QUAD $0x67902e276c921f8c // .quad 7462515329413029772 + QUAD $0x806bd9714632dff6 // .quad -9193015133814464522 + QUAD $0x00ba1cd8a3db53b7 // .quad 52386062455755703 + QUAD $0xa086cfcd97bf97f3 // .quad -6879582898840692749 + QUAD $0x80e8a40eccd228a5 // .quad -9157889458785081179 + QUAD $0xc8a883c0fdaf7df0 // .quad -3987792605123478032 + QUAD $0x6122cd128006b2ce // .quad 6999382250228200142 + QUAD $0xfad2a4b13d1b5d6c // .quad -373054737976959636 + QUAD $0x796b805720085f82 // .quad 8749227812785250178 + QUAD $0x9cc3a6eec6311a63 // .quad -7150688238876681629 + QUAD $0xcbe3303674053bb1 // .quad -3755104653863994447 + QUAD $0xc3f490aa77bd60fc // .quad -4326674280168464132 + QUAD $0xbedbfc4411068a9d // .quad -4693880817329993059 + QUAD $0xf4f1b4d515acb93b // .quad -796656831783192261 + QUAD $0xee92fb5515482d45 // .quad -1255665003235103419 + QUAD $0x991711052d8bf3c5 // .quad -7415439547505577019 + QUAD $0x751bdd152d4d1c4b // .quad 8438581409832836171 + QUAD $0xbf5cd54678eef0b6 // .quad -4657613415954583370 + QUAD $0xd262d45a78a0635e // .quad -3286831292991118498 + QUAD $0xef340a98172aace4 // .quad -1210330751515841308 + QUAD $0x86fb897116c87c35 // .quad -8720225134666286027 + QUAD $0x9580869f0e7aac0e // .quad -7673985747338482674 + QUAD $0xd45d35e6ae3d4da1 // .quad -3144297699952734815 + QUAD $0xbae0a846d2195712 // .quad -4980796165745715438 + QUAD $0x8974836059cca10a // .quad -8542058143368306422 + QUAD $0xe998d258869facd7 // .quad -1614309188754756393 + QUAD $0x2bd1a438703fc94c // .quad 3157485376071780684 + QUAD $0x91ff83775423cc06 // .quad -7926472270612804602 + QUAD $0x7b6306a34627ddd0 // .quad 8890957387685944784 + QUAD $0xb67f6455292cbf08 // .quad -5296404319838617848 + QUAD $0x1a3bc84c17b1d543 // .quad 1890324697752655171 + QUAD $0xe41f3d6a7377eeca // .quad -2008819381370884406 + QUAD $0x20caba5f1d9e4a94 // .quad 2362905872190818964 + QUAD $0x8e938662882af53e // .quad -8173041140997884610 + QUAD $0x547eb47b7282ee9d // .quad 6088502188546649757 + QUAD $0xb23867fb2a35b28d // .quad -5604615407819967859 + QUAD $0xe99e619a4f23aa44 // .quad -1612744301171463612 + QUAD $0xdec681f9f4c31f31 // .quad -2394083241347571919 + QUAD $0x6405fa00e2ec94d5 // .quad 7207441660390446293 + QUAD $0x8b3c113c38f9f37e // .quad -8413831053483314306 + QUAD $0xde83bc408dd3dd05 // .quad -2412877989897052923 + QUAD $0xae0b158b4738705e // .quad -5905602798426754978 + QUAD $0x9624ab50b148d446 // .quad -7627783505798704058 + QUAD $0xd98ddaee19068c76 // .quad -2770317479606055818 + QUAD $0x3badd624dd9b0958 // .quad 4300328673033783640 + QUAD $0x87f8a8d4cfa417c9 // .quad -8648977452394866743 + QUAD $0xe54ca5d70a80e5d7 // .quad -1923980597781273129 + QUAD $0xa9f6d30a038d1dbc // .quad -6199535797066195524 + QUAD $0x5e9fcf4ccd211f4d // .quad 6818396289628184397 + QUAD $0xd47487cc8470652b // .quad -3137733727905356501 + QUAD $0x7647c32000696720 // .quad 8522995362035230496 + QUAD $0x84c8d4dfd2c63f3b // .quad -8878612607581929669 + QUAD $0x29ecd9f40041e074 // .quad 3021029092058325108 + QUAD $0xa5fb0a17c777cf09 // .quad -6486579741050024183 + QUAD $0xf468107100525891 // .quad -835399653354481519 + QUAD $0xcf79cc9db955c2cc // .quad -3496538657885142324 + QUAD $0x7182148d4066eeb5 // .quad 8179122470161673909 + QUAD $0x81ac1fe293d599bf // .quad -9102865688819295809 + QUAD $0xc6f14cd848405531 // .quad -4111420493003729615 + QUAD $0xa21727db38cb002f // .quad -6766896092596731857 + QUAD $0xb8ada00e5a506a7d // .quad -5139275616254662019 + QUAD $0xca9cf1d206fdc03b // .quad -3846934097318526917 + QUAD $0xa6d90811f0e4851d // .quad -6424094520318327523 + QUAD $0xfd442e4688bd304a // .quad -196981603220770742 + QUAD $0x908f4a166d1da664 // .quad -8030118150397909404 + QUAD $0x9e4a9cec15763e2e // .quad -7040642529654063570 + QUAD $0x9a598e4e043287ff // .quad -7324666853212387329 + QUAD $0xc5dd44271ad3cdba // .quad -4189117143640191558 + QUAD $0x40eff1e1853f29fe // .quad 4679224488766679550 + QUAD $0xf7549530e188c128 // .quad -624710411122851544 + QUAD $0xd12bee59e68ef47d // .quad -3374341425896426371 + QUAD $0x9a94dd3e8cf578b9 // .quad -7307973034592864071 + QUAD $0x82bb74f8301958cf // .quad -9026492418826348337 + QUAD $0xc13a148e3032d6e7 // .quad -4523280274813692185 + QUAD $0xe36a52363c1faf02 // .quad -2059743486678159614 + QUAD $0xf18899b1bc3f8ca1 // .quad -1042414325089727327 + QUAD $0xdc44e6c3cb279ac2 // .quad -2574679358347699518 + QUAD $0x96f5600f15a7b7e5 // .quad -7569037980822161435 + QUAD $0x29ab103a5ef8c0ba // .quad 3002511419460075706 + QUAD $0xbcb2b812db11a5de // .quad -4849611457600313890 + QUAD $0x7415d448f6b6f0e8 // .quad 8364825292752482536 + QUAD $0xebdf661791d60f56 // .quad -1450328303573004458 + QUAD $0x111b495b3464ad22 // .quad 1232659579085827362 + QUAD $0x936b9fcebb25c995 // .quad -7823984217374209643 + QUAD $0xcab10dd900beec35 // .quad -3841273781498745803 + QUAD $0xb84687c269ef3bfb // .quad -5168294253290374149 + QUAD $0x3d5d514f40eea743 // .quad 4421779809981343555 + QUAD $0xe65829b3046b0afa // .quad -1848681798185579782 + QUAD $0x0cb4a5a3112a5113 // .quad 915538744049291539 + QUAD $0x8ff71a0fe2c2e6dc // .quad -8072955151507069220 + QUAD $0x47f0e785eaba72ac // .quad 5183897733458195116 + QUAD $0xb3f4e093db73a093 // .quad -5479507920956448621 + QUAD $0x59ed216765690f57 // .quad 6479872166822743895 + QUAD $0xe0f218b8d25088b8 // .quad -2237698882768172872 + QUAD $0x306869c13ec3532d // .quad 3488154190101041965 + QUAD $0x8c974f7383725573 // .quad -8316090829371189901 + QUAD $0x1e414218c73a13fc // .quad 2180096368813151228 + QUAD $0xafbd2350644eeacf // .quad -5783427518286599473 + QUAD $0xe5d1929ef90898fb // .quad -1886565557410948869 + QUAD $0xdbac6c247d62a583 // .quad -2617598379430861437 + QUAD $0xdf45f746b74abf3a // .quad -2358206946763686086 + QUAD $0x894bc396ce5da772 // .quad -8553528014785370254 + QUAD $0x6b8bba8c328eb784 // .quad 7749492695127472004 + QUAD $0xab9eb47c81f5114f // .quad -6080224000054324913 + QUAD $0x066ea92f3f326565 // .quad 463493832054564197 + QUAD $0xd686619ba27255a2 // .quad -2988593981640518238 + QUAD $0xc80a537b0efefebe // .quad -4032318728359182658 + QUAD $0x8613fd0145877585 // .quad -8785400266166405755 + QUAD $0xbd06742ce95f5f37 // .quad -4826042214438183113 + QUAD $0xa798fc4196e952e7 // .quad -6370064314280619289 + QUAD $0x2c48113823b73705 // .quad 3190819268807046917 + QUAD $0xd17f3b51fca3a7a0 // .quad -3350894374423386208 + QUAD $0xf75a15862ca504c6 // .quad -623161932418579258 + QUAD $0x82ef85133de648c4 // .quad -9011838011655698236 + QUAD $0x9a984d73dbe722fc // .quad -7307005235402693892 + QUAD $0xa3ab66580d5fdaf5 // .quad -6653111496142234891 + QUAD $0xc13e60d0d2e0ebbb // .quad -4522070525825979461 + QUAD $0xcc963fee10b7d1b3 // .quad -3704703351750405709 + QUAD $0x318df905079926a9 // .quad 3570783879572301481 + QUAD $0xffbbcfe994e5c61f // .quad -19193171260619233 + QUAD $0xfdf17746497f7053 // .quad -148206168962011053 + QUAD $0x9fd561f1fd0f9bd3 // .quad -6929524759678968877 + QUAD $0xfeb6ea8bedefa634 // .quad -92628855601256908 + QUAD $0xc7caba6e7c5382c8 // .quad -4050219931171323192 + QUAD $0xfe64a52ee96b8fc1 // .quad -115786069501571135 + QUAD $0xf9bd690a1b68637b // .quad -451088895536766085 + QUAD $0x3dfdce7aa3c673b1 // .quad 4466953431550423985 + QUAD $0x9c1661a651213e2d // .quad -7199459587351560659 + QUAD $0x06bea10ca65c084f // .quad 486002885505321039 + QUAD $0xc31bfa0fe5698db8 // .quad -4387638465762062920 + QUAD $0x486e494fcff30a63 // .quad 5219189625309039203 + QUAD $0xf3e2f893dec3f126 // .quad -872862063775190746 + QUAD $0x5a89dba3c3efccfb // .quad 6523987031636299003 + QUAD $0x986ddb5c6b3a76b7 // .quad -7463067817500576073 + QUAD $0xf89629465a75e01d // .quad -534194123654701027 + QUAD $0xbe89523386091465 // .quad -4717148753448332187 + QUAD $0xf6bbb397f1135824 // .quad -667742654568376284 + QUAD $0xee2ba6c0678b597f // .quad -1284749923383027329 + QUAD $0x746aa07ded582e2d // .quad 8388693718644305453 + QUAD $0x94db483840b717ef // .quad -7720497729755473937 + QUAD $0xa8c2a44eb4571cdd // .quad -6286281471915778851 + QUAD $0xba121a4650e4ddeb // .quad -5038936143766954517 + QUAD $0x92f34d62616ce414 // .quad -7857851839894723564 + QUAD $0xe896a0d7e51e1566 // .quad -1686984161281305242 + QUAD $0x77b020baf9c81d18 // .quad 8624429273841147160 + QUAD $0x915e2486ef32cd60 // .quad -7971894128441897632 + QUAD $0x0ace1474dc1d122f // .quad 778582277723329071 + QUAD $0xb5b5ada8aaff80b8 // .quad -5353181642124984136 + QUAD $0x0d819992132456bb // .quad 973227847154161339 + QUAD $0xe3231912d5bf60e6 // .quad -2079791034228842266 + QUAD $0x10e1fff697ed6c6a // .quad 1216534808942701674 + QUAD $0x8df5efabc5979c8f // .quad -8217398424034108273 + QUAD $0xca8d3ffa1ef463c2 // .quad -3851351762838199358 + QUAD $0xb1736b96b6fd83b3 // .quad -5660062011615247437 + QUAD $0xbd308ff8a6b17cb3 // .quad -4814189703547749197 + QUAD $0xddd0467c64bce4a0 // .quad -2463391496091671392 + QUAD $0xac7cb3f6d05ddbdf // .quad -6017737129434686497 + QUAD $0x8aa22c0dbef60ee4 // .quad -8457148712698376476 + QUAD $0x6bcdf07a423aa96c // .quad 7768129340171790700 + QUAD $0xad4ab7112eb3929d // .quad -5959749872445582691 + QUAD $0x86c16c98d2c953c7 // .quad -8736582398494813241 + QUAD $0xd89d64d57a607744 // .quad -2838001322129590460 + QUAD $0xe871c7bf077ba8b8 // .quad -1697355961263740744 + QUAD $0x87625f056c7c4a8b // .quad -8691279853972075893 + QUAD $0x11471cd764ad4973 // .quad 1244995533423855987 + QUAD $0xa93af6c6c79b5d2d // .quad -6252413799037706963 + QUAD $0xd598e40d3dd89bd0 // .quad -3055441601647567920 + QUAD $0xd389b47879823479 // .quad -3203831230369745799 + QUAD $0x4aff1d108d4ec2c4 // .quad 5404070034795315908 + QUAD $0x843610cb4bf160cb // .quad -8919923546622172981 + QUAD $0xcedf722a585139bb // .quad -3539985255894009413 + QUAD $0xa54394fe1eedb8fe // .quad -6538218414850328322 + QUAD $0xc2974eb4ee658829 // .quad -4424981569867511767 + QUAD $0xce947a3da6a9273e // .quad -3561087000135522498 + QUAD $0x733d226229feea33 // .quad 8303831092947774003 + QUAD $0x811ccc668829b887 // .quad -9143208402725783417 + QUAD $0x0806357d5a3f5260 // .quad 578208414664970848 + QUAD $0xa163ff802a3426a8 // .quad -6817324484979841368 + QUAD $0xca07c2dcb0cf26f8 // .quad -3888925500096174344 + QUAD $0xc9bcff6034c13052 // .quad -3909969587797413806 + QUAD $0xfc89b393dd02f0b6 // .quad -249470856692830026 + QUAD $0xfc2c3f3841f17c67 // .quad -275775966319379353 + QUAD $0xbbac2078d443ace3 // .quad -4923524589293425437 + QUAD $0x9d9ba7832936edc0 // .quad -7089889006590693952 + QUAD $0xd54b944b84aa4c0e // .quad -3077202868308390898 + QUAD $0xc5029163f384a931 // .quad -4250675239810979535 + QUAD $0x0a9e795e65d4df12 // .quad 765182433041899282 + QUAD $0xf64335bcf065d37d // .quad -701658031336336515 + QUAD $0x4d4617b5ff4a16d6 // .quad 5568164059729762006 + QUAD $0x99ea0196163fa42e // .quad -7356065297226292178 + QUAD $0x504bced1bf8e4e46 // .quad 5785945546544795206 + QUAD $0xc06481fb9bcf8d39 // .quad -4583395603105477319 + QUAD $0xe45ec2862f71e1d7 // .quad -1990940103673781801 + QUAD $0xf07da27a82c37088 // .quad -1117558485454458744 + QUAD $0x5d767327bb4e5a4d // .quad 6734696907262548557 + QUAD $0x964e858c91ba2655 // .quad -7616003081050118571 + QUAD $0x3a6a07f8d510f870 // .quad 4209185567039092848 + QUAD $0xbbe226efb628afea // .quad -4908317832885260310 + QUAD $0x890489f70a55368c // .quad -8573576096483297652 + QUAD $0xeadab0aba3b2dbe5 // .quad -1523711272679187483 + QUAD $0x2b45ac74ccea842f // .quad 3118087934678041647 + QUAD $0x92c8ae6b464fc96f // .quad -7869848573065574033 + QUAD $0x3b0b8bc90012929e // .quad 4254647968387469982 + QUAD $0xb77ada0617e3bbcb // .quad -5225624697904579637 + QUAD $0x09ce6ebb40173745 // .quad 706623942056949573 + QUAD $0xe55990879ddcaabd // .quad -1920344853953336643 + QUAD $0xcc420a6a101d0516 // .quad -3728406090856200938 + QUAD $0x8f57fa54c2a9eab6 // .quad -8117744561361917258 + QUAD $0x9fa946824a12232e // .quad -6941939825212513490 + QUAD $0xb32df8e9f3546564 // .quad -5535494683275008668 + QUAD $0x47939822dc96abfa // .quad 5157633273766521850 + QUAD $0xdff9772470297ebd // .quad -2307682335666372931 + QUAD $0x59787e2b93bc56f8 // .quad 6447041592208152312 + QUAD $0x8bfbea76c619ef36 // .quad -8359830487432564938 + QUAD $0x57eb4edb3c55b65b // .quad 6335244004343789147 + QUAD $0xaefae51477a06b03 // .quad -5838102090863318269 + QUAD $0xede622920b6b23f2 // .quad -1304317031425039374 + QUAD $0xdab99e59958885c4 // .quad -2685941595151759932 + QUAD $0xe95fab368e45ecee // .quad -1630396289281299218 + QUAD $0x88b402f7fd75539b // .quad -8596242524610931813 + QUAD $0x11dbcb0218ebb415 // .quad 1286845328412881941 + QUAD $0xaae103b5fcd2a881 // .quad -6133617137336276863 + QUAD $0xd652bdc29f26a11a // .quad -3003129357911285478 + QUAD $0xd59944a37c0752a2 // .quad -3055335403242958174 + QUAD $0x4be76d3346f04960 // .quad 5469460339465668960 + QUAD $0x857fcae62d8493a5 // .quad -8827113654667930715 + QUAD $0x6f70a4400c562ddc // .quad 8030098730593431004 + QUAD $0xa6dfbd9fb8e5b88e // .quad -6422206049907525490 + QUAD $0xcb4ccd500f6bb953 // .quad -3797434642040374957 + QUAD $0xd097ad07a71f26b2 // .quad -3416071543957018958 + QUAD $0x7e2000a41346a7a8 // .quad 9088264752731695016 + QUAD $0x825ecc24c873782f // .quad -9052573742614218705 + QUAD $0x8ed400668c0c28c9 // .quad -8154892584824854327 + QUAD $0xa2f67f2dfa90563b // .quad -6704031159840385477 + QUAD $0x728900802f0f32fb // .quad 8253128342678483707 + QUAD $0xcbb41ef979346bca // .quad -3768352931373093942 + QUAD $0x4f2b40a03ad2ffba // .quad 5704724409920716730 + QUAD $0xfea126b7d78186bc // .quad -98755145788979524 + QUAD $0xe2f610c84987bfa9 // .quad -2092466524453879895 + QUAD $0x9f24b832e6b0f436 // .quad -6979250993759194058 + QUAD $0x0dd9ca7d2df4d7ca // .quad 998051431430019018 + QUAD $0xc6ede63fa05d3143 // .quad -4112377723771604669 + QUAD $0x91503d1c79720dbc // .quad -7975807747567252036 + QUAD $0xf8a95fcf88747d94 // .quad -528786136287117932 + QUAD $0x75a44c6397ce912b // .quad 8476984389250486571 + QUAD $0x9b69dbe1b548ce7c // .quad -7248020362820530564 + QUAD $0xc986afbe3ee11abb // .quad -3925256793573221701 + QUAD $0xc24452da229b021b // .quad -4448339435098275301 + QUAD $0xfbe85badce996169 // .quad -294884973539139223 + QUAD $0xf2d56790ab41c2a2 // .quad -948738275445456222 + QUAD $0xfae27299423fb9c4 // .quad -368606216923924028 + QUAD $0x97c560ba6b0919a5 // .quad -7510490449794491995 + QUAD $0xdccd879fc967d41b // .quad -2536221894791146469 + QUAD $0xbdb6b8e905cb600f // .quad -4776427043815727089 + QUAD $0x5400e987bbc1c921 // .quad 6053094668365842721 + QUAD $0xed246723473e3813 // .quad -1358847786342270957 + QUAD $0x290123e9aab23b69 // .quad 2954682317029915497 + QUAD $0x9436c0760c86e30b // .quad -7766808894105001205 + QUAD $0xf9a0b6720aaf6522 // .quad -459166561069996766 + QUAD $0xb94470938fa89bce // .quad -5096825099203863602 + QUAD $0xf808e40e8d5b3e6a // .quad -573958201337495958 + QUAD $0xe7958cb87392c2c2 // .quad -1759345355577441598 + QUAD $0xb60b1d1230b20e05 // .quad -5329133770099257851 + QUAD $0x90bd77f3483bb9b9 // .quad -8017119874876982855 + QUAD $0xb1c6f22b5e6f48c3 // .quad -5636551615525730109 + QUAD $0xb4ecd5f01a4aa828 // .quad -5409713825168840664 + QUAD $0x1e38aeb6360b1af4 // .quad 2177682517447613172 + QUAD $0xe2280b6c20dd5232 // .quad -2150456263033662926 + QUAD $0x25c6da63c38de1b1 // .quad 2722103146809516465 + QUAD $0x8d590723948a535f // .quad -8261564192037121185 + QUAD $0x579c487e5a38ad0f // .quad 6313000485183335695 + QUAD $0xb0af48ec79ace837 // .quad -5715269221619013577 + QUAD $0x2d835a9df0c6d852 // .quad 3279564588051781714 + QUAD $0xdcdb1b2798182244 // .quad -2532400508596379068 + QUAD $0xf8e431456cf88e66 // .quad -512230283362660762 + QUAD $0x8a08f0f8bf0f156b // .quad -8500279345513818773 + QUAD $0x1b8e9ecb641b5900 // .quad 1985699082112030976 + QUAD $0xac8b2d36eed2dac5 // .quad -6013663163464885563 + QUAD $0xe272467e3d222f40 // .quad -2129562165787349184 + QUAD $0xd7adf884aa879177 // .quad -2905392935903719049 + QUAD $0x5b0ed81dcc6abb10 // .quad 6561419329620589328 + QUAD $0x86ccbb52ea94baea // .quad -8733399612580906262 + QUAD $0x98e947129fc2b4ea // .quad -7428327965055601430 + QUAD $0xa87fea27a539e9a5 // .quad -6305063497298744923 + QUAD $0x3f2398d747b36225 // .quad 4549648098962661925 + QUAD $0xd29fe4b18e88640e // .quad -3269643353196043250 + QUAD $0x8eec7f0d19a03aae // .quad -8147997931578836306 + QUAD $0x83a3eeeef9153e89 // .quad -8961056123388608887 + QUAD $0x1953cf68300424ad // .quad 1825030320404309165 + QUAD $0xa48ceaaab75a8e2b // .quad -6589634135808373205 + QUAD $0x5fa8c3423c052dd8 // .quad 6892973918932774360 + QUAD $0xcdb02555653131b6 // .quad -3625356651333078602 + QUAD $0x3792f412cb06794e // .quad 4004531380238580046 + QUAD $0x808e17555f3ebf11 // .quad -9183376934724255983 + QUAD $0xe2bbd88bbee40bd1 // .quad -2108853905778275375 + QUAD $0xa0b19d2ab70e6ed6 // .quad -6867535149977932074 + QUAD $0x5b6aceaeae9d0ec5 // .quad 6587304654631931589 + QUAD $0xc8de047564d20a8b // .quad -3972732919045027189 + QUAD $0xf245825a5a445276 // .quad -989241218564861322 + QUAD $0xfb158592be068d2e // .quad -354230130378896082 + QUAD $0xeed6e2f0f0d56713 // .quad -1236551523206076653 + QUAD $0x9ced737bb6c4183d // .quad -7138922859127891907 + QUAD $0x55464dd69685606c // .quad 6144684325637283948 + QUAD $0xc428d05aa4751e4c // .quad -4311967555482476980 + QUAD $0xaa97e14c3c26b887 // .quad -6154202648235558777 + QUAD $0xf53304714d9265df // .quad -778273425925708321 + QUAD $0xd53dd99f4b3066a9 // .quad -3081067291867060567 + QUAD $0x993fe2c6d07b7fab // .quad -7403949918844649557 + QUAD $0xe546a8038efe402a // .quad -1925667057416912854 + QUAD $0xbf8fdb78849a5f96 // .quad -4643251380128424042 + QUAD $0xde98520472bdd034 // .quad -2407083821771141068 + QUAD $0xef73d256a5c0f77c // .quad -1192378206733142148 + QUAD $0x963e66858f6d4441 // .quad -7620540795641314239 + QUAD $0x95a8637627989aad // .quad -7662765406849295699 + QUAD $0xdde7001379a44aa9 // .quad -2456994988062127447 + QUAD $0xbb127c53b17ec159 // .quad -4966770740134231719 + QUAD $0x5560c018580d5d53 // .quad 6152128301777116499 + QUAD $0xe9d71b689dde71af // .quad -1596777406740401745 + QUAD $0xaab8f01e6e10b4a7 // .quad -6144897678060768089 + QUAD $0x9226712162ab070d // .quad -7915514906853832947 + QUAD $0xcab3961304ca70e9 // .quad -3840561048787980055 + QUAD $0xb6b00d69bb55c8d1 // .quad -5282707615139903279 + QUAD $0x3d607b97c5fd0d23 // .quad 4422670725869800739 + QUAD $0xe45c10c42a2b3b05 // .quad -1991698500497491195 + QUAD $0x8cb89a7db77c506b // .quad -8306719647944912789 + QUAD $0x8eb98a7a9a5b04e3 // .quad -8162340590452013853 + QUAD $0x77f3608e92adb243 // .quad 8643358275316593219 + QUAD $0xb267ed1940f1c61c // .quad -5591239719637629412 + QUAD $0x55f038b237591ed4 // .quad 6192511825718353620 + QUAD $0xdf01e85f912e37a3 // .quad -2377363631119648861 + QUAD $0x6b6c46dec52f6689 // .quad 7740639782147942025 + QUAD $0x8b61313bbabce2c6 // .quad -8403381297090862394 + QUAD $0x2323ac4b3b3da016 // .quad 2532056854628769814 + QUAD $0xae397d8aa96c1b77 // .quad -5892540602936190089 + QUAD $0xabec975e0a0d081b // .quad -6058300968568813541 + QUAD $0xd9c7dced53c72255 // .quad -2753989735242849707 + QUAD $0x96e7bd358c904a22 // .quad -7572876210711016926 + QUAD $0x881cea14545c7575 // .quad -8638772612167862923 + QUAD $0x7e50d64177da2e55 // .quad 9102010423587778133 + QUAD $0xaa242499697392d2 // .quad -6186779746782440750 + QUAD $0xdde50bd1d5d0b9ea // .quad -2457545025797441046 + QUAD $0xd4ad2dbfc3d07787 // .quad -3121788665050663033 + QUAD $0x955e4ec64b44e865 // .quad -7683617300674189211 + QUAD $0x84ec3c97da624ab4 // .quad -8868646943297746252 + QUAD $0xbd5af13bef0b113f // .quad -4802260812921368257 + QUAD $0xa6274bbdd0fadd61 // .quad -6474122660694794911 + QUAD $0xecb1ad8aeacdd58f // .quad -1391139997724322417 + QUAD $0xcfb11ead453994ba // .quad -3480967307441105734 + QUAD $0x67de18eda5814af3 // .quad 7484447039699372787 + QUAD $0x81ceb32c4b43fcf4 // .quad -9093133594791772940 + QUAD $0x80eacf948770ced8 // .quad -9157278655470055720 + QUAD $0xa2425ff75e14fc31 // .quad -6754730975062328271 + QUAD $0xa1258379a94d028e // .quad -6834912300910181746 + QUAD $0xcad2f7f5359a3b3e // .quad -3831727700400522434 + QUAD $0x096ee45813a04331 // .quad 679731660717048625 + QUAD $0xfd87b5f28300ca0d // .quad -177973607073265139 + QUAD $0x8bca9d6e188853fd // .quad -8373707460958465027 + QUAD $0x9e74d1b791e07e48 // .quad -7028762532061872568 + QUAD $0x775ea264cf55347e // .quad 8601490892183123070 + QUAD $0xc612062576589dda // .quad -4174267146649952806 + QUAD $0x95364afe032a819e // .quad -7694880458480647778 + QUAD $0xf79687aed3eec551 // .quad -606147914885053103 + QUAD $0x3a83ddbd83f52205 // .quad 4216457482181353989 + QUAD $0x9abe14cd44753b52 // .quad -7296371474444240046 + QUAD $0xc4926a9672793543 // .quad -4282243101277735613 + QUAD $0xc16d9a0095928a27 // .quad -4508778324627912153 + QUAD $0x75b7053c0f178294 // .quad 8482254178684994196 + QUAD $0xf1c90080baf72cb1 // .quad -1024286887357502287 + QUAD $0x5324c68b12dd6339 // .quad 5991131704928854841 + QUAD $0x971da05074da7bee // .quad -7557708332239520786 + QUAD $0xd3f6fc16ebca5e04 // .quad -3173071712060547580 + QUAD $0xbce5086492111aea // .quad -4835449396872013078 + QUAD $0x88f4bb1ca6bcf585 // .quad -8578025658503072379 + QUAD $0xec1e4a7db69561a5 // .quad -1432625727662628443 + QUAD $0x2b31e9e3d06c32e6 // .quad 3112525982153323238 + QUAD $0x9392ee8e921d5d07 // .quad -7812920107430224633 + QUAD $0x3aff322e62439fd0 // .quad 4251171748059520976 + QUAD $0xb877aa3236a4b449 // .quad -5154464115860392887 + QUAD $0x09befeb9fad487c3 // .quad 702278666647013315 + QUAD $0xe69594bec44de15b // .quad -1831394126398103205 + QUAD $0x4c2ebe687989a9b4 // .quad 5489534351736154548 + QUAD $0x901d7cf73ab0acd9 // .quad -8062150356639896359 + QUAD $0x0f9d37014bf60a11 // .quad 1125115960621402641 + QUAD $0xb424dc35095cd80f // .quad -5466001927372482545 + QUAD $0x538484c19ef38c95 // .quad 6018080969204141205 + QUAD $0xe12e13424bb40e13 // .quad -2220816390788215277 + QUAD $0x2865a5f206b06fba // .quad 2910915193077788602 + QUAD $0x8cbccc096f5088cb // .quad -8305539271883716405 + QUAD $0xf93f87b7442e45d4 // .quad -486521013540076076 + QUAD $0xafebff0bcb24aafe // .quad -5770238071427257602 + QUAD $0xf78f69a51539d749 // .quad -608151266925095095 + QUAD $0xdbe6fecebdedd5be // .quad -2601111570856684098 + QUAD $0xb573440e5a884d1c // .quad -5371875102083756772 + QUAD $0x89705f4136b4a597 // .quad -8543223759426509417 + QUAD $0x31680a88f8953031 // .quad 3560107088838733873 + QUAD $0xabcc77118461cefc // .quad -6067343680855748868 + QUAD $0xfdc20d2b36ba7c3e // .quad -161552157378970562 + QUAD $0xd6bf94d5e57a42bc // .quad -2972493582642298180 + QUAD $0x3d32907604691b4d // .quad 4409745821703674701 + QUAD $0x8637bd05af6c69b5 // .quad -8775337516792518219 + QUAD $0xa63f9a49c2c1b110 // .quad -6467280898289979120 + QUAD $0xa7c5ac471b478423 // .quad -6357485877563259869 + QUAD $0x0fcf80dc33721d54 // .quad 1139270913992301908 + QUAD $0xd1b71758e219652b // .quad -3335171328526686933 + QUAD $0xd3c36113404ea4a9 // .quad -3187597375937010519 + QUAD $0x83126e978d4fdf3b // .quad -9002011107970261189 + QUAD $0x645a1cac083126ea // .quad 7231123676894144234 + QUAD $0xa3d70a3d70a3d70a // .quad -6640827866535438582 + QUAD $0x3d70a3d70a3d70a4 // .quad 4427218577690292388 + QUAD $0xcccccccccccccccc // .quad -3689348814741910324 + QUAD $0xcccccccccccccccd // .quad -3689348814741910323 + QUAD $0x8000000000000000 // .quad -9223372036854775808 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa000000000000000 // .quad -6917529027641081856 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc800000000000000 // .quad -4035225266123964416 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xfa00000000000000 // .quad -432345564227567616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9c40000000000000 // .quad -7187745005283311616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc350000000000000 // .quad -4372995238176751616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xf424000000000000 // .quad -854558029293551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9896800000000000 // .quad -7451627795949551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xbebc200000000000 // .quad -4702848726509551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xee6b280000000000 // .quad -1266874889709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9502f90000000000 // .quad -7709325833709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xba43b74000000000 // .quad -5024971273709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe8d4a51000000000 // .quad -1669528073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9184e72a00000000 // .quad -7960984073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb5e620f480000000 // .quad -5339544073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe35fa931a0000000 // .quad -2062744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8ac7230489e80000 // .quad -8446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x878678326eac9000 // .quad -8681119073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa968163f0a57b400 // .quad -6239712823709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x84595161401484a0 // .quad -8910000909647051616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x813f3978f8940984 // .quad -9133518327554766460 + QUAD $0x4000000000000000 // .quad 4611686018427387904 + QUAD $0xa18f07d736b90be5 // .quad -6805211891016070171 + QUAD $0x5000000000000000 // .quad 5764607523034234880 + QUAD $0xc9f2c9cd04674ede // .quad -3894828845342699810 + QUAD $0xa400000000000000 // .quad -6629298651489370112 + QUAD $0xfc6f7c4045812296 // .quad -256850038250986858 + QUAD $0x4d00000000000000 // .quad 5548434740920451072 + QUAD $0x9dc5ada82b70b59d // .quad -7078060301547948643 + QUAD $0xf020000000000000 // .quad -1143914305352105984 + QUAD $0xc5371912364ce305 // .quad -4235889358507547899 + QUAD $0x6c28000000000000 // .quad 7793479155164643328 + QUAD $0xf684df56c3e01bc6 // .quad -683175679707046970 + QUAD $0xc732000000000000 // .quad -4093209111326359552 + QUAD $0x9a130b963a6c115c // .quad -7344513827457986212 + QUAD $0x3c7f400000000000 // .quad 4359273333062107136 + QUAD $0xc097ce7bc90715b3 // .quad -4568956265895094861 + QUAD $0x4b9f100000000000 // .quad 5449091666327633920 + QUAD $0xf0bdc21abb48db20 // .quad -1099509313941480672 + QUAD $0x1e86d40000000000 // .quad 2199678564482154496 + QUAD $0x96769950b50d88f4 // .quad -7604722348854507276 + QUAD $0x1314448000000000 // .quad 1374799102801346560 + QUAD $0xbc143fa4e250eb31 // .quad -4894216917640746191 + QUAD $0x17d955a000000000 // .quad 1718498878501683200 + QUAD $0xeb194f8e1ae525fd // .quad -1506085128623544835 + QUAD $0x5dcfab0800000000 // .quad 6759809616554491904 + QUAD $0x92efd1b8d0cf37be // .quad -7858832233030797378 + QUAD $0x5aa1cae500000000 // .quad 6530724019560251392 + QUAD $0xb7abc627050305ad // .quad -5211854272861108819 + QUAD $0xf14a3d9e40000000 // .quad -1059967012404461568 + QUAD $0xe596b7b0c643c719 // .quad -1903131822648998119 + QUAD $0x6d9ccd05d0000000 // .quad 7898413271349198848 + QUAD $0x8f7e32ce7bea5c6f // .quad -8106986416796705681 + QUAD $0xe4820023a2000000 // .quad -1981020733047832576 + QUAD $0xb35dbf821ae4f38b // .quad -5522047002568494197 + QUAD $0xdda2802c8a800000 // .quad -2476275916309790720 + QUAD $0xe0352f62a19e306e // .quad -2290872734783229842 + QUAD $0xd50b2037ad200000 // .quad -3095344895387238400 + QUAD $0x8c213d9da502de45 // .quad -8349324486880600507 + QUAD $0x4526f422cc340000 // .quad 4982938468024057856 + QUAD $0xaf298d050e4395d6 // .quad -5824969590173362730 + QUAD $0x9670b12b7f410000 // .quad -7606384970252091392 + QUAD $0xdaf3f04651d47b4c // .quad -2669525969289315508 + QUAD $0x3c0cdd765f114000 // .quad 4327076842467049472 + QUAD $0x88d8762bf324cd0f // .quad -8585982758446904049 + QUAD $0xa5880a69fb6ac800 // .quad -6518949010312869888 + QUAD $0xab0e93b6efee0053 // .quad -6120792429631242157 + QUAD $0x8eea0d047a457a00 // .quad -8148686262891087360 + QUAD $0xd5d238a4abe98068 // .quad -3039304518611664792 + QUAD $0x72a4904598d6d880 // .quad 8260886245095692416 + QUAD $0x85a36366eb71f041 // .quad -8817094351773372351 + QUAD $0x47a6da2b7f864750 // .quad 5163053903184807760 + QUAD $0xa70c3c40a64e6c51 // .quad -6409681921289327535 + QUAD $0x999090b65f67d924 // .quad -7381240676301154012 + QUAD $0xd0cf4b50cfe20765 // .quad -3400416383184271515 + QUAD $0xfff4b4e3f741cf6d // .quad -3178808521666707 + QUAD $0x82818f1281ed449f // .quad -9042789267131251553 + QUAD $0xbff8f10e7a8921a5 // .quad -4613672773753429595 + QUAD $0xa321f2d7226895c7 // .quad -6691800565486676537 + QUAD $0xaff72d52192b6a0e // .quad -5767090967191786994 + QUAD $0xcbea6f8ceb02bb39 // .quad -3753064688430957767 + QUAD $0x9bf4f8a69f764491 // .quad -7208863708989733743 + QUAD $0xfee50b7025c36a08 // .quad -79644842111309304 + QUAD $0x02f236d04753d5b5 // .quad 212292400617608629 + QUAD $0x9f4f2726179a2245 // .quad -6967307053960650171 + QUAD $0x01d762422c946591 // .quad 132682750386005393 + QUAD $0xc722f0ef9d80aad6 // .quad -4097447799023424810 + QUAD $0x424d3ad2b7b97ef6 // .quad 4777539456409894646 + QUAD $0xf8ebad2b84e0d58b // .quad -510123730351893109 + QUAD $0xd2e0898765a7deb3 // .quad -3251447716342407501 + QUAD $0x9b934c3b330c8577 // .quad -7236356359111015049 + QUAD $0x63cc55f49f88eb30 // .quad 7191217214140771120 + QUAD $0xc2781f49ffcfa6d5 // .quad -4433759430461380907 + QUAD $0x3cbf6b71c76b25fc // .quad 4377335499248575996 + QUAD $0xf316271c7fc3908a // .quad -930513269649338230 + QUAD $0x8bef464e3945ef7b // .quad -8363388681221443717 + QUAD $0x97edd871cfda3a56 // .quad -7499099821171918250 + QUAD $0x97758bf0e3cbb5ad // .quad -7532960934977096275 + QUAD $0xbde94e8e43d0c8ec // .quad -4762188758037509908 + QUAD $0x3d52eeed1cbea318 // .quad 4418856886560793368 + QUAD $0xed63a231d4c4fb27 // .quad -1341049929119499481 + QUAD $0x4ca7aaa863ee4bde // .quad 5523571108200991710 + QUAD $0x945e455f24fb1cf8 // .quad -7755685233340769032 + QUAD $0x8fe8caa93e74ef6b // .quad -8076983103442849941 + QUAD $0xb975d6b6ee39e436 // .quad -5082920523248573386 + QUAD $0xb3e2fd538e122b45 // .quad -5484542860876174523 + QUAD $0xe7d34c64a9c85d44 // .quad -1741964635633328828 + QUAD $0x60dbbca87196b617 // .quad 6979379479186945559 + QUAD $0x90e40fbeea1d3a4a // .quad -8006256924911912374 + QUAD $0xbc8955e946fe31ce // .quad -4861259862362934834 + QUAD $0xb51d13aea4a488dd // .quad -5396135137712502563 + QUAD $0x6babab6398bdbe42 // .quad 7758483227328495170 + QUAD $0xe264589a4dcdab14 // .quad -2133482903713240300 + QUAD $0xc696963c7eed2dd2 // .quad -4136954021121544750 + QUAD $0x8d7eb76070a08aec // .quad -8250955842461857044 + QUAD $0xfc1e1de5cf543ca3 // .quad -279753253987271517 + QUAD $0xb0de65388cc8ada8 // .quad -5702008784649933400 + QUAD $0x3b25a55f43294bcc // .quad 4261994450943298508 + QUAD $0xdd15fe86affad912 // .quad -2515824962385028846 + QUAD $0x49ef0eb713f39ebf // .quad 5327493063679123135 + QUAD $0x8a2dbf142dfcc7ab // .quad -8489919629131724885 + QUAD $0x6e3569326c784338 // .quad 7941369183226839864 + QUAD $0xacb92ed9397bf996 // .quad -6000713517987268202 + QUAD $0x49c2c37f07965405 // .quad 5315025460606161925 + QUAD $0xd7e77a8f87daf7fb // .quad -2889205879056697349 + QUAD $0xdc33745ec97be907 // .quad -2579590211097073401 + QUAD $0x86f0ac99b4e8dafd // .quad -8723282702051517699 + QUAD $0x69a028bb3ded71a4 // .quad 7611128154919104932 + QUAD $0xa8acd7c0222311bc // .quad -6292417359137009220 + QUAD $0xc40832ea0d68ce0d // .quad -4321147861633282547 + QUAD $0xd2d80db02aabd62b // .quad -3253835680493873621 + QUAD $0xf50a3fa490c30191 // .quad -789748808614215279 + QUAD $0x83c7088e1aab65db // .quad -8951176327949752869 + QUAD $0x792667c6da79e0fb // .quad 8729779031470891259 + QUAD $0xa4b8cab1a1563f52 // .quad -6577284391509803182 + QUAD $0x577001b891185939 // .quad 6300537770911226169 + QUAD $0xcde6fd5e09abcf26 // .quad -3609919470959866074 + QUAD $0xed4c0226b55e6f87 // .quad -1347699823215743097 + QUAD $0x80b05e5ac60b6178 // .quad -9173728696990998152 + QUAD $0x544f8158315b05b5 // .quad 6075216638131242421 + QUAD $0xa0dc75f1778e39d6 // .quad -6855474852811359786 + QUAD $0x696361ae3db1c722 // .quad 7594020797664053026 + QUAD $0xc913936dd571c84c // .quad -3957657547586811828 + QUAD $0x03bc3a19cd1e38ea // .quad 269153960225290474 + QUAD $0xfb5878494ace3a5f // .quad -335385916056126881 + QUAD $0x04ab48a04065c724 // .quad 336442450281613092 + QUAD $0x9d174b2dcec0e47b // .quad -7127145225176161157 + QUAD $0x62eb0d64283f9c77 // .quad 7127805559067090039 + QUAD $0xc45d1df942711d9a // .quad -4297245513042813542 + QUAD $0x3ba5d0bd324f8395 // .quad 4298070930406474645 + QUAD $0xf5746577930d6500 // .quad -759870872876129024 + QUAD $0xca8f44ec7ee3647a // .quad -3850783373846682502 + QUAD $0x9968bf6abbe85f20 // .quad -7392448323188662496 + QUAD $0x7e998b13cf4e1ecc // .quad 9122475437414293196 + QUAD $0xbfc2ef456ae276e8 // .quad -4628874385558440216 + QUAD $0x9e3fedd8c321a67f // .quad -7043649776941685121 + QUAD $0xefb3ab16c59b14a2 // .quad -1174406963520662366 + QUAD $0xc5cfe94ef3ea101f // .quad -4192876202749718497 + QUAD $0x95d04aee3b80ece5 // .quad -7651533379841495835 + QUAD $0xbba1f1d158724a13 // .quad -4926390635932268013 + QUAD $0xbb445da9ca61281f // .quad -4952730706374481889 + QUAD $0x2a8a6e45ae8edc98 // .quad 3065383741939440792 + QUAD $0xea1575143cf97226 // .quad -1579227364540714458 + QUAD $0xf52d09d71a3293be // .quad -779956341003086914 + QUAD $0x924d692ca61be758 // .quad -7904546130479028392 + QUAD $0x593c2626705f9c57 // .quad 6430056314514152535 + QUAD $0xb6e0c377cfa2e12e // .quad -5268996644671397586 + QUAD $0x6f8b2fb00c77836d // .quad 8037570393142690669 + QUAD $0xe498f455c38b997a // .quad -1974559787411859078 + QUAD $0x0b6dfb9c0f956448 // .quad 823590954573587528 + QUAD $0x8edf98b59a373fec // .quad -8151628894773493780 + QUAD $0x4724bd4189bd5ead // .quad 5126430365035880109 + QUAD $0xb2977ee300c50fe7 // .quad -5577850100039479321 + QUAD $0x58edec91ec2cb658 // .quad 6408037956294850136 + QUAD $0xdf3d5e9bc0f653e1 // .quad -2360626606621961247 + QUAD $0x2f2967b66737e3ee // .quad 3398361426941174766 + QUAD $0x8b865b215899f46c // .quad -8392920656779807636 + QUAD $0xbd79e0d20082ee75 // .quad -4793553135802847627 + QUAD $0xae67f1e9aec07187 // .quad -5879464802547371641 + QUAD $0xecd8590680a3aa12 // .quad -1380255401326171630 + QUAD $0xda01ee641a708de9 // .quad -2737644984756826647 + QUAD $0xe80e6f4820cc9496 // .quad -1725319251657714538 + QUAD $0x884134fe908658b2 // .quad -8628557143114098510 + QUAD $0x3109058d147fdcde // .quad 3533361486141316318 + QUAD $0xaa51823e34a7eede // .quad -6174010410465235234 + QUAD $0xbd4b46f0599fd416 // .quad -4806670179178130410 + QUAD $0xd4e5e2cdc1d1ea96 // .quad -3105826994654156138 + QUAD $0x6c9e18ac7007c91b // .quad 7826720331309500699 + QUAD $0x850fadc09923329e // .quad -8858670899299929442 + QUAD $0x03e2cf6bc604ddb1 // .quad 280014188641050033 + QUAD $0xa6539930bf6bff45 // .quad -6461652605697523899 + QUAD $0x84db8346b786151d // .quad -8873354301053463267 + QUAD $0xcfe87f7cef46ff16 // .quad -3465379738694516970 + QUAD $0xe612641865679a64 // .quad -1868320839462053276 + QUAD $0x81f14fae158c5f6e // .quad -9083391364325154962 + QUAD $0x4fcb7e8f3f60c07f // .quad 5749828502977298559 + QUAD $0xa26da3999aef7749 // .quad -6742553186979055799 + QUAD $0xe3be5e330f38f09e // .quad -2036086408133152610 + QUAD $0xcb090c8001ab551c // .quad -3816505465296431844 + QUAD $0x5cadf5bfd3072cc6 // .quad 6678264026688335046 + QUAD $0xfdcb4fa002162a63 // .quad -158945813193151901 + QUAD $0x73d9732fc7c8f7f7 // .quad 8347830033360418807 + QUAD $0x9e9f11c4014dda7e // .quad -7016870160886801794 + QUAD $0x2867e7fddcdd9afb // .quad 2911550761636567803 + QUAD $0xc646d63501a1511d // .quad -4159401682681114339 + QUAD $0xb281e1fd541501b9 // .quad -5583933584809066055 + QUAD $0xf7d88bc24209a565 // .quad -587566084924005019 + QUAD $0x1f225a7ca91a4227 // .quad 2243455055843443239 + QUAD $0x9ae757596946075f // .quad -7284757830718584993 + QUAD $0x3375788de9b06959 // .quad 3708002419115845977 + QUAD $0xc1a12d2fc3978937 // .quad -4494261269970843337 + QUAD $0x0052d6b1641c83af // .quad 23317005467419567 + QUAD $0xf209787bb47d6b84 // .quad -1006140569036166268 + QUAD $0xc0678c5dbd23a49b // .quad -4582539761593113445 + QUAD $0x9745eb4d50ce6332 // .quad -7546366883288685774 + QUAD $0xf840b7ba963646e1 // .quad -558244341782001951 + QUAD $0xbd176620a501fbff // .quad -4821272585683469313 + QUAD $0xb650e5a93bc3d899 // .quad -5309491445654890343 + QUAD $0xec5d3fa8ce427aff // .quad -1414904713676948737 + QUAD $0xa3e51f138ab4cebf // .quad -6636864307068612929 + QUAD $0x93ba47c980e98cdf // .quad -7801844473689174817 + QUAD $0xc66f336c36b10138 // .quad -4148040191917883080 + QUAD $0xb8a8d9bbe123f017 // .quad -5140619573684080617 + QUAD $0xb80b0047445d4185 // .quad -5185050239897353851 + QUAD $0xe6d3102ad96cec1d // .quad -1814088448677712867 + QUAD $0xa60dc059157491e6 // .quad -6481312799871692314 + QUAD $0x9043ea1ac7e41392 // .quad -8051334308064652398 + QUAD $0x87c89837ad68db30 // .quad -8662506518347195600 + QUAD $0xb454e4a179dd1877 // .quad -5452481866653427593 + QUAD $0x29babe4598c311fc // .quad 3006924907348169212 + QUAD $0xe16a1dc9d8545e94 // .quad -2203916314889396588 + QUAD $0xf4296dd6fef3d67b // .quad -853029884242176389 + QUAD $0x8ce2529e2734bb1d // .quad -8294976724446954723 + QUAD $0x1899e4a65f58660d // .quad 1772699331562333709 + QUAD $0xb01ae745b101e9e4 // .quad -5757034887131305500 + QUAD $0x5ec05dcff72e7f90 // .quad 6827560182880305040 + QUAD $0xdc21a1171d42645d // .quad -2584607590486743971 + QUAD $0x76707543f4fa1f74 // .quad 8534450228600381300 + QUAD $0x899504ae72497eba // .quad -8532908771695296838 + QUAD $0x6a06494a791c53a9 // .quad 7639874402088932265 + QUAD $0xabfa45da0edbde69 // .quad -6054449946191733143 + QUAD $0x0487db9d17636893 // .quad 326470965756389523 + QUAD $0xd6f8d7509292d603 // .quad -2956376414312278525 + QUAD $0x45a9d2845d3c42b7 // .quad 5019774725622874807 + QUAD $0x865b86925b9bc5c2 // .quad -8765264286586255934 + QUAD $0x0b8a2392ba45a9b3 // .quad 831516194300602803 + QUAD $0xa7f26836f282b732 // .quad -6344894339805432014 + QUAD $0x8e6cac7768d7141f // .quad -8183976793979022305 + QUAD $0xd1ef0244af2364ff // .quad -3319431906329402113 + QUAD $0x3207d795430cd927 // .quad 3605087062808385831 + QUAD $0x8335616aed761f1f // .quad -8992173969096958177 + QUAD $0x7f44e6bd49e807b9 // .quad 9170708441896323001 + QUAD $0xa402b9c5a8d3a6e7 // .quad -6628531442943809817 + QUAD $0x5f16206c9c6209a7 // .quad 6851699533943015847 + QUAD $0xcd036837130890a1 // .quad -3673978285252374367 + QUAD $0x36dba887c37a8c10 // .quad 3952938399001381904 + QUAD $0x802221226be55a64 // .quad -9213765455923815836 + QUAD $0xc2494954da2c978a // .quad -4446942528265218166 + QUAD $0xa02aa96b06deb0fd // .quad -6905520801477381891 + QUAD $0xf2db9baa10b7bd6d // .quad -946992141904134803 + QUAD $0xc83553c5c8965d3d // .quad -4020214983419339459 + QUAD $0x6f92829494e5acc8 // .quad 8039631859474607304 + QUAD $0xfa42a8b73abbf48c // .quad -413582710846786420 + QUAD $0xcb772339ba1f17fa // .quad -3785518230938904582 + QUAD $0x9c69a97284b578d7 // .quad -7176018221920323369 + QUAD $0xff2a760414536efc // .quad -60105885123121412 + QUAD $0xc38413cf25e2d70d // .quad -4358336758973016307 + QUAD $0xfef5138519684abb // .quad -75132356403901765 + QUAD $0xf46518c2ef5b8cd1 // .quad -836234930288882479 + QUAD $0x7eb258665fc25d6a // .quad 9129456591349898602 + QUAD $0x98bf2f79d5993802 // .quad -7440175859071633406 + QUAD $0xef2f773ffbd97a62 // .quad -1211618658047395230 + QUAD $0xbeeefb584aff8603 // .quad -4688533805412153853 + QUAD $0xaafb550ffacfd8fb // .quad -6126209340986631941 + QUAD $0xeeaaba2e5dbf6784 // .quad -1248981238337804412 + QUAD $0x95ba2a53f983cf39 // .quad -7657761676233289927 + QUAD $0x952ab45cfa97a0b2 // .quad -7698142301602209614 + QUAD $0xdd945a747bf26184 // .quad -2480258038432112252 + QUAD $0xba756174393d88df // .quad -5010991858575374113 + QUAD $0x94f971119aeef9e5 // .quad -7712008566467528219 + QUAD $0xe912b9d1478ceb17 // .quad -1652053804791829737 + QUAD $0x7a37cd5601aab85e // .quad 8806733365625141342 + QUAD $0x91abb422ccb812ee // .quad -7950062655635975442 + QUAD $0xac62e055c10ab33b // .quad -6025006692552756421 + QUAD $0xb616a12b7fe617aa // .quad -5325892301117581398 + QUAD $0x577b986b314d600a // .quad 6303799689591218186 + QUAD $0xe39c49765fdf9d94 // .quad -2045679357969588844 + QUAD $0xed5a7e85fda0b80c // .quad -1343622424865753076 + QUAD $0x8e41ade9fbebc27d // .quad -8196078626372074883 + QUAD $0x14588f13be847308 // .quad 1466078993672598280 + QUAD $0xb1d219647ae6b31c // .quad -5633412264537705700 + QUAD $0x596eb2d8ae258fc9 // .quad 6444284760518135753 + QUAD $0xde469fbd99a05fe3 // .quad -2430079312244744221 + QUAD $0x6fca5f8ed9aef3bc // .quad 8055355950647669692 + QUAD $0x8aec23d680043bee // .quad -8436328597794046994 + QUAD $0x25de7bb9480d5855 // .quad 2728754459941099605 + QUAD $0xada72ccc20054ae9 // .quad -5933724728815170839 + QUAD $0xaf561aa79a10ae6b // .quad -5812428961928401301 + QUAD $0xd910f7ff28069da4 // .quad -2805469892591575644 + QUAD $0x1b2ba1518094da05 // .quad 1957835834444274181 + QUAD $0x87aa9aff79042286 // .quad -8670947710510816634 + QUAD $0x90fb44d2f05d0843 // .quad -7999724640327104445 + QUAD $0xa99541bf57452b28 // .quad -6226998619711132888 + QUAD $0x353a1607ac744a54 // .quad 3835402254873283156 + QUAD $0xd3fa922f2d1675f2 // .quad -3172062256211528206 + QUAD $0x42889b8997915ce9 // .quad 4794252818591603945 + QUAD $0x847c9b5d7c2e09b7 // .quad -8900067937773286985 + QUAD $0x69956135febada12 // .quad 7608094030047140370 + QUAD $0xa59bc234db398c25 // .quad -6513398903789220827 + QUAD $0x43fab9837e699096 // .quad 4898431519131537558 + QUAD $0xcf02b2c21207ef2e // .quad -3530062611309138130 + QUAD $0x94f967e45e03f4bc // .quad -7712018656367741764 + QUAD $0x8161afb94b44f57d // .quad -9123818159709293187 + QUAD $0x1d1be0eebac278f6 // .quad 2097517367411243254 + QUAD $0xa1ba1ba79e1632dc // .quad -6793086681209228580 + QUAD $0x6462d92a69731733 // .quad 7233582727691441971 + QUAD $0xca28a291859bbf93 // .quad -3879672333084147821 + QUAD $0x7d7b8f7503cfdcff // .quad 9041978409614302463 + QUAD $0xfcb2cb35e702af78 // .quad -237904397927796872 + QUAD $0x5cda735244c3d43f // .quad 6690786993590490175 + QUAD $0x9defbf01b061adab // .quad -7066219276345954901 + QUAD $0x3a0888136afa64a8 // .quad 4181741870994056360 + QUAD $0xc56baec21c7a1916 // .quad -4221088077005055722 + QUAD $0x088aaa1845b8fdd1 // .quad 615491320315182545 + QUAD $0xf6c69a72a3989f5b // .quad -664674077828931749 + QUAD $0x8aad549e57273d46 // .quad -8454007886460797626 + QUAD $0x9a3c2087a63f6399 // .quad -7332950326284164199 + QUAD $0x36ac54e2f678864c // .quad 3939617107816777292 + QUAD $0xc0cb28a98fcf3c7f // .quad -4554501889427817345 + QUAD $0x84576a1bb416a7de // .quad -8910536670511192098 + QUAD $0xf0fdf2d3f3c30b9f // .quad -1081441343357383777 + QUAD $0x656d44a2a11c51d6 // .quad 7308573235570561494 + QUAD $0x969eb7c47859e743 // .quad -7593429867239446717 + QUAD $0x9f644ae5a4b1b326 // .quad -6961356773836868826 + QUAD $0xbc4665b596706114 // .quad -4880101315621920492 + QUAD $0x873d5d9f0dde1fef // .quad -8701695967296086033 + QUAD $0xeb57ff22fc0c7959 // .quad -1488440626100012711 + QUAD $0xa90cb506d155a7eb // .quad -6265433940692719637 + QUAD $0x9316ff75dd87cbd8 // .quad -7847804418953589800 + QUAD $0x09a7f12442d588f3 // .quad 695789805494438131 + QUAD $0xb7dcbf5354e9bece // .quad -5198069505264599346 + QUAD $0x0c11ed6d538aeb30 // .quad 869737256868047664 + QUAD $0xe5d3ef282a242e81 // .quad -1885900863153361279 + QUAD $0x8f1668c8a86da5fb // .quad -8136200465769716229 + QUAD $0x8fa475791a569d10 // .quad -8096217067111932656 + QUAD $0xf96e017d694487bd // .quad -473439272678684739 + QUAD $0xb38d92d760ec4455 // .quad -5508585315462527915 + QUAD $0x37c981dcc395a9ad // .quad 4019886927579031981 + QUAD $0xe070f78d3927556a // .quad -2274045625900771990 + QUAD $0x85bbe253f47b1418 // .quad -8810199395808373736 + QUAD $0x8c469ab843b89562 // .quad -8338807543829064350 + QUAD $0x93956d7478ccec8f // .quad -7812217631593927537 + QUAD $0xaf58416654a6babb // .quad -5811823411358942533 + QUAD $0x387ac8d1970027b3 // .quad 4069786015789754291 + QUAD $0xdb2e51bfe9d0696a // .quad -2653093245771290262 + QUAD $0x06997b05fcc0319f // .quad 475546501309804959 + QUAD $0x88fcf317f22241e2 // .quad -8575712306248138270 + QUAD $0x441fece3bdf81f04 // .quad 4908902581746016004 + QUAD $0xab3c2fddeeaad25a // .quad -6107954364382784934 + QUAD $0xd527e81cad7626c4 // .quad -3087243809672255804 + QUAD $0xd60b3bd56a5586f1 // .quad -3023256937051093263 + QUAD $0x8a71e223d8d3b075 // .quad -8470740780517707659 + QUAD $0x85c7056562757456 // .quad -8807064613298015146 + QUAD $0xf6872d5667844e4a // .quad -682526969396179382 + QUAD $0xa738c6bebb12d16c // .quad -6397144748195131028 + QUAD $0xb428f8ac016561dc // .quad -5464844730172612132 + QUAD $0xd106f86e69d785c7 // .quad -3384744916816525881 + QUAD $0xe13336d701beba53 // .quad -2219369894288377261 + QUAD $0x82a45b450226b39c // .quad -9032994600651410532 + QUAD $0xecc0024661173474 // .quad -1387106183930235788 + QUAD $0xa34d721642b06084 // .quad -6679557232386875260 + QUAD $0x27f002d7f95d0191 // .quad 2877803288514593169 + QUAD $0xcc20ce9bd35c78a5 // .quad -3737760522056206171 + QUAD $0x31ec038df7b441f5 // .quad 3597254110643241461 + QUAD $0xff290242c83396ce // .quad -60514634142869810 + QUAD $0x7e67047175a15272 // .quad 9108253656731439730 + QUAD $0x9f79a169bd203e41 // .quad -6955350673980375487 + QUAD $0x0f0062c6e984d387 // .quad 1080972517029761927 + QUAD $0xc75809c42c684dd1 // .quad -4082502324048081455 + QUAD $0x52c07b78a3e60869 // .quad 5962901664714590313 + QUAD $0xf92e0c3537826145 // .quad -491441886632713915 + QUAD $0xa7709a56ccdf8a83 // .quad -6381430974388925821 + QUAD $0x9bbcc7a142b17ccb // .quad -7224680206786528053 + QUAD $0x88a66076400bb692 // .quad -8600080377420466542 + QUAD $0xc2abf989935ddbfe // .quad -4419164240055772162 + QUAD $0x6acff893d00ea436 // .quad 7696643601933968438 + QUAD $0xf356f7ebf83552fe // .quad -912269281642327298 + QUAD $0x0583f6b8c4124d44 // .quad 397432465562684740 + QUAD $0x98165af37b2153de // .quad -7487697328667536418 + QUAD $0xc3727a337a8b704b // .quad -4363290727450709941 + QUAD $0xbe1bf1b059e9a8d6 // .quad -4747935642407032618 + QUAD $0x744f18c0592e4c5d // .quad 8380944645968776285 + QUAD $0xeda2ee1c7064130c // .quad -1323233534581402868 + QUAD $0x1162def06f79df74 // .quad 1252808770606194548 + QUAD $0x9485d4d1c63e8be7 // .quad -7744549986754458649 + QUAD $0x8addcb5645ac2ba9 // .quad -8440366555225904215 + QUAD $0xb9a74a0637ce2ee1 // .quad -5069001465015685407 + QUAD $0x6d953e2bd7173693 // .quad 7896285879677171347 + QUAD $0xe8111c87c5c1ba99 // .quad -1724565812842218855 + QUAD $0xc8fa8db6ccdd0438 // .quad -3964700705685699528 + QUAD $0x910ab1d4db9914a0 // .quad -7995382660667468640 + QUAD $0x1d9c9892400a22a3 // .quad 2133748077373825699 + QUAD $0xb54d5e4a127f59c8 // .quad -5382542307406947896 + QUAD $0x2503beb6d00cab4c // .quad 2667185096717282124 + QUAD $0xe2a0b5dc971f303a // .quad -2116491865831296966 + QUAD $0x2e44ae64840fd61e // .quad 3333981370896602654 + QUAD $0x8da471a9de737e24 // .quad -8240336443785642460 + QUAD $0x5ceaecfed289e5d3 // .quad 6695424375237764563 + QUAD $0xb10d8e1456105dad // .quad -5688734536304665171 + QUAD $0x7425a83e872c5f48 // .quad 8369280469047205704 + QUAD $0xdd50f1996b947518 // .quad -2499232151953443560 + QUAD $0xd12f124e28f7771a // .quad -3373457468973156582 + QUAD $0x8a5296ffe33cc92f // .quad -8479549122611984081 + QUAD $0x82bd6b70d99aaa70 // .quad -9025939945749304720 + QUAD $0xace73cbfdc0bfb7b // .quad -5987750384837592197 + QUAD $0x636cc64d1001550c // .quad 7164319141522920716 + QUAD $0xd8210befd30efa5a // .quad -2873001962619602342 + QUAD $0x3c47f7e05401aa4f // .quad 4343712908476262991 + QUAD $0x8714a775e3e95c78 // .quad -8713155254278333320 + QUAD $0x65acfaec34810a72 // .quad 7326506586225052274 + QUAD $0xa8d9d1535ce3b396 // .quad -6279758049420528746 + QUAD $0x7f1839a741a14d0e // .quad 9158133232781315342 + QUAD $0xd31045a8341ca07c // .quad -3238011543348273028 + QUAD $0x1ede48111209a051 // .quad 2224294504121868369 + QUAD $0x83ea2b892091e44d // .quad -8941286242233752499 + QUAD $0x934aed0aab460433 // .quad -7833187971778608077 + QUAD $0xa4e4b66b68b65d60 // .quad -6564921784364802720 + QUAD $0xf81da84d56178540 // .quad -568112927868484288 + QUAD $0xce1de40642e3f4b9 // .quad -3594466212028615495 + QUAD $0x36251260ab9d668f // .quad 3901544858591782543 + QUAD $0x80d2ae83e9ce78f3 // .quad -9164070410158966541 + QUAD $0xc1d72b7c6b42601a // .quad -4479063491021217766 + QUAD $0xa1075a24e4421730 // .quad -6843401994271320272 + QUAD $0xb24cf65b8612f820 // .quad -5598829363776522208 + QUAD $0xc94930ae1d529cfc // .quad -3942566474411762436 + QUAD $0xdee033f26797b628 // .quad -2386850686293264856 + QUAD $0xfb9b7cd9a4a7443c // .quad -316522074587315140 + QUAD $0x169840ef017da3b2 // .quad 1628122660560806834 + QUAD $0x9d412e0806e88aa5 // .quad -7115355324258153819 + QUAD $0x8e1f289560ee864f // .quad -8205795374004271537 + QUAD $0xc491798a08a2ad4e // .quad -4282508136895304370 + QUAD $0xf1a6f2bab92a27e3 // .quad -1033872180650563613 + QUAD $0xf5b5d7ec8acb58a2 // .quad -741449152691742558 + QUAD $0xae10af696774b1dc // .quad -5904026244240592420 + QUAD $0x9991a6f3d6bf1765 // .quad -7380934748073420955 + QUAD $0xacca6da1e0a8ef2a // .quad -5995859411864064214 + QUAD $0xbff610b0cc6edd3f // .quad -4614482416664388289 + QUAD $0x17fd090a58d32af4 // .quad 1728547772024695540 + QUAD $0xeff394dcff8a948e // .quad -1156417002403097458 + QUAD $0xddfc4b4cef07f5b1 // .quad -2451001303396518479 + QUAD $0x95f83d0a1fb69cd9 // .quad -7640289654143017767 + QUAD $0x4abdaf101564f98f // .quad 5385653213018257807 + QUAD $0xbb764c4ca7a4440f // .quad -4938676049251384305 + QUAD $0x9d6d1ad41abe37f2 // .quad -7102991539009341454 + QUAD $0xea53df5fd18d5513 // .quad -1561659043136842477 + QUAD $0x84c86189216dc5ee // .quad -8878739423761676818 + QUAD $0x92746b9be2f8552c // .quad -7893565929601608404 + QUAD $0x32fd3cf5b4e49bb5 // .quad 3674159897003727797 + QUAD $0xb7118682dbb66a77 // .quad -5255271393574622601 + QUAD $0x3fbc8c33221dc2a2 // .quad 4592699871254659746 + QUAD $0xe4d5e82392a40515 // .quad -1957403223540890347 + QUAD $0x0fabaf3feaa5334b // .quad 1129188820640936779 + QUAD $0x8f05b1163ba6832d // .quad -8140906042354138323 + QUAD $0x29cb4d87f2a7400f // .quad 3011586022114279439 + QUAD $0xb2c71d5bca9023f8 // .quad -5564446534515285000 + QUAD $0x743e20e9ef511013 // .quad 8376168546070237203 + QUAD $0xdf78e4b2bd342cf6 // .quad -2343872149716718346 + QUAD $0x914da9246b255417 // .quad -7976533391121755113 + QUAD $0x8bab8eefb6409c1a // .quad -8382449121214030822 + QUAD $0x1ad089b6c2f7548f // .quad 1932195658189984911 + QUAD $0xae9672aba3d0c320 // .quad -5866375383090150624 + QUAD $0xa184ac2473b529b2 // .quad -6808127464117294670 + QUAD $0xda3c0f568cc4f3e8 // .quad -2721283210435300376 + QUAD $0xc9e5d72d90a2741f // .quad -3898473311719230433 + QUAD $0x8865899617fb1871 // .quad -8618331034163144591 + QUAD $0x7e2fa67c7a658893 // .quad 9092669226243950739 + QUAD $0xaa7eebfb9df9de8d // .quad -6161227774276542835 + QUAD $0xddbb901b98feeab8 // .quad -2469221522477225288 + QUAD $0xd51ea6fa85785631 // .quad -3089848699418290639 + QUAD $0x552a74227f3ea566 // .quad 6136845133758244198 + QUAD $0x8533285c936b35de // .quad -8848684464777513506 + QUAD $0xd53a88958f872760 // .quad -3082000819042179232 + QUAD $0xa67ff273b8460356 // .quad -6449169562544503978 + QUAD $0x8a892abaf368f138 // .quad -8464187042230111944 + QUAD $0xd01fef10a657842c // .quad -3449775934753242068 + QUAD $0x2d2b7569b0432d86 // .quad 3254824252494523782 + QUAD $0x8213f56a67f6b29b // .quad -9073638986861858149 + QUAD $0x9c3b29620e29fc74 // .quad -7189106879045698444 + QUAD $0xa298f2c501f45f42 // .quad -6730362715149934782 + QUAD $0x8349f3ba91b47b90 // .quad -8986383598807123056 + QUAD $0xcb3f2f7642717713 // .quad -3801267375510030573 + QUAD $0x241c70a936219a74 // .quad 2602078556773259892 + QUAD $0xfe0efb53d30dd4d7 // .quad -139898200960150313 + QUAD $0xed238cd383aa0111 // .quad -1359087822460813039 + QUAD $0x9ec95d1463e8a506 // .quad -7004965403241175802 + QUAD $0xf4363804324a40ab // .quad -849429889038008149 + QUAD $0xc67bb4597ce2ce48 // .quad -4144520735624081848 + QUAD $0xb143c6053edcd0d6 // .quad -5673473379724898090 + QUAD $0xf81aa16fdc1b81da // .quad -568964901102714406 + QUAD $0xdd94b7868e94050b // .quad -2480155706228734709 + QUAD $0x9b10a4e5e9913128 // .quad -7273132090830278360 + QUAD $0xca7cf2b4191c8327 // .quad -3855940325606653145 + QUAD $0xc1d4ce1f63f57d72 // .quad -4479729095110460046 + QUAD $0xfd1c2f611f63a3f1 // .quad -208239388580928527 + QUAD $0xf24a01a73cf2dccf // .quad -987975350460687153 + QUAD $0xbc633b39673c8ced // .quad -4871985254153548563 + QUAD $0x976e41088617ca01 // .quad -7535013621679011327 + QUAD $0xd5be0503e085d814 // .quad -3044990783845967852 + QUAD $0xbd49d14aa79dbc82 // .quad -4807081008671376254 + QUAD $0x4b2d8644d8a74e19 // .quad 5417133557047315993 + QUAD $0xec9c459d51852ba2 // .quad -1397165242411832414 + QUAD $0xddf8e7d60ed1219f // .quad -2451955090545630817 + QUAD $0x93e1ab8252f33b45 // .quad -7790757304148477115 + QUAD $0xcabb90e5c942b504 // .quad -3838314940804713212 + QUAD $0xb8da1662e7b00a17 // .quad -5126760611758208489 + QUAD $0x3d6a751f3b936244 // .quad 4425478360848884292 + QUAD $0xe7109bfba19c0c9d // .quad -1796764746270372707 + QUAD $0x0cc512670a783ad5 // .quad 920161932633717461 + QUAD $0x906a617d450187e2 // .quad -8040506994060064798 + QUAD $0x27fb2b80668b24c6 // .quad 2880944217109767366 + QUAD $0xb484f9dc9641e9da // .quad -5438947724147693094 + QUAD $0xb1f9f660802dedf7 // .quad -5622191765467566601 + QUAD $0xe1a63853bbd26451 // .quad -2186998636757228463 + QUAD $0x5e7873f8a0396974 // .quad 6807318348447705460 + QUAD $0x8d07e33455637eb2 // .quad -8284403175614349646 + QUAD $0xdb0b487b6423e1e9 // .quad -2662955059861265943 + QUAD $0xb049dc016abc5e5f // .quad -5743817951090549153 + QUAD $0x91ce1a9a3d2cda63 // .quad -7940379843253970333 + QUAD $0xdc5c5301c56b75f7 // .quad -2568086420435798537 + QUAD $0x7641a140cc7810fc // .quad 8521269269642088700 + QUAD $0x89b9b3e11b6329ba // .quad -8522583040413455942 + QUAD $0xa9e904c87fcb0a9e // .quad -6203421752542164322 + QUAD $0xac2820d9623bf429 // .quad -6041542782089432023 + QUAD $0x546345fa9fbdcd45 // .quad 6080780864604458309 + QUAD $0xd732290fbacaf133 // .quad -2940242459184402125 + QUAD $0xa97c177947ad4096 // .quad -6234081974526590826 + QUAD $0x867f59a9d4bed6c0 // .quad -8755180564631333184 + QUAD $0x49ed8eabcccc485e // .quad 5327070802775656542 + QUAD $0xa81f301449ee8c70 // .quad -6332289687361778576 + QUAD $0x5c68f256bfff5a75 // .quad 6658838503469570677 + QUAD $0xd226fc195c6a2f8c // .quad -3303676090774835316 + QUAD $0x73832eec6fff3112 // .quad 8323548129336963346 + QUAD $0x83585d8fd9c25db7 // .quad -8982326584375353929 + QUAD $0xc831fd53c5ff7eac // .quad -4021154456019173716 + QUAD $0xa42e74f3d032f525 // .quad -6616222212041804507 + QUAD $0xba3e7ca8b77f5e56 // .quad -5026443070023967146 + QUAD $0xcd3a1230c43fb26f // .quad -3658591746624867729 + QUAD $0x28ce1bd2e55f35ec // .quad 2940318199324816876 + QUAD $0x80444b5e7aa7cf85 // .quad -9204148869281624187 + QUAD $0x7980d163cf5b81b4 // .quad 8755227902219092404 + QUAD $0xa0555e361951c366 // .quad -6893500068174642330 + QUAD $0xd7e105bcc3326220 // .quad -2891023177508298208 + QUAD $0xc86ab5c39fa63440 // .quad -4005189066790915008 + QUAD $0x8dd9472bf3fefaa8 // .quad -8225464990312760664 + QUAD $0xfa856334878fc150 // .quad -394800315061255856 + QUAD $0xb14f98f6f0feb952 // .quad -5670145219463562926 + QUAD $0x9c935e00d4b9d8d2 // .quad -7164279224554366766 + QUAD $0x6ed1bf9a569f33d4 // .quad 7985374283903742932 + QUAD $0xc3b8358109e84f07 // .quad -4343663012265570553 + QUAD $0x0a862f80ec4700c9 // .quad 758345818024902857 + QUAD $0xf4a642e14c6262c8 // .quad -817892746904575288 + QUAD $0xcd27bb612758c0fb // .quad -3663753745896259333 + QUAD $0x98e7e9cccfbd7dbd // .quad -7428711994456441411 + QUAD $0x8038d51cb897789d // .quad -9207375118826243939 + QUAD $0xbf21e44003acdd2c // .quad -4674203974643163860 + QUAD $0xe0470a63e6bd56c4 // .quad -2285846861678029116 + QUAD $0xeeea5d5004981478 // .quad -1231068949876566920 + QUAD $0x1858ccfce06cac75 // .quad 1754377441329851509 + QUAD $0x95527a5202df0ccb // .quad -7686947121313936181 + QUAD $0x0f37801e0c43ebc9 // .quad 1096485900831157193 + QUAD $0xbaa718e68396cffd // .quad -4996997883215032323 + QUAD $0xd30560258f54e6bb // .quad -3241078642388441413 + QUAD $0xe950df20247c83fd // .quad -1634561335591402499 + QUAD $0x47c6b82ef32a206a // .quad 5172023733869224042 + QUAD $0x91d28b7416cdd27e // .quad -7939129862385708418 + QUAD $0x4cdc331d57fa5442 // .quad 5538357842881958978 + QUAD $0xb6472e511c81471d // .quad -5312226309554747619 + QUAD $0xe0133fe4adf8e953 // .quad -2300424733252327085 + QUAD $0xe3d8f9e563a198e5 // .quad -2028596868516046619 + QUAD $0x58180fddd97723a7 // .quad 6347841120289366951 + QUAD $0x8e679c2f5e44ff8f // .quad -8185402070463610993 + QUAD $0x570f09eaa7ea7649 // .quad 6273243709394548297 + QUAD $0xb201833b35d63f73 // .quad -5620066569652125837 + QUAD $0x2cd2cc6551e513db // .quad 3229868618315797467 + QUAD $0xde81e40a034bcf4f // .quad -2413397193637769393 + QUAD $0xf8077f7ea65e58d2 // .quad -574350245532641070 + QUAD $0x8b112e86420f6191 // .quad -8425902273664687727 + QUAD $0xfb04afaf27faf783 // .quad -358968903457900669 + QUAD $0xadd57a27d29339f6 // .quad -5920691823653471754 + QUAD $0x79c5db9af1f9b564 // .quad 8774660907532399972 + QUAD $0xd94ad8b1c7380874 // .quad -2789178761139451788 + QUAD $0x18375281ae7822bd // .quad 1744954097560724157 + QUAD $0x87cec76f1c830548 // .quad -8660765753353239224 + QUAD $0x8f2293910d0b15b6 // .quad -8132775725879323210 + QUAD $0xa9c2794ae3a3c69a // .quad -6214271173264161126 + QUAD $0xb2eb3875504ddb23 // .quad -5554283638921766109 + QUAD $0xd433179d9c8cb841 // .quad -3156152948152813503 + QUAD $0x5fa60692a46151ec // .quad 6892203506629956076 + QUAD $0x849feec281d7f328 // .quad -8890124620236590296 + QUAD $0xdbc7c41ba6bcd334 // .quad -2609901835997359308 + QUAD $0xa5c7ea73224deff3 // .quad -6500969756868349965 + QUAD $0x12b9b522906c0801 // .quad 1349308723430688769 + QUAD $0xcf39e50feae16bef // .quad -3514526177658049553 + QUAD $0xd768226b34870a01 // .quad -2925050114139026943 + QUAD $0x81842f29f2cce375 // .quad -9114107888677362827 + QUAD $0xe6a1158300d46641 // .quad -1828156321336891839 + QUAD $0xa1e53af46f801c53 // .quad -6780948842419315629 + QUAD $0x60495ae3c1097fd1 // .quad 6938176635183661009 + QUAD $0xca5e89b18b602368 // .quad -3864500034596756632 + QUAD $0x385bb19cb14bdfc5 // .quad 4061034775552188357 + QUAD $0xfcf62c1dee382c42 // .quad -218939024818557886 + QUAD $0x46729e03dd9ed7b6 // .quad 5076293469440235446 + QUAD $0x9e19db92b4e31ba9 // .quad -7054365918152680535 + QUAD $0x6c07a2c26a8346d2 // .quad 7784369436827535058 + + // .p2align 4, 0x00 +_VecShiftShuffles: + QUAD $0x0706050403020100; QUAD $0x0f0e0d0c0b0a0908 // .ascii 16, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' + QUAD $0x0807060504030201; QUAD $0xff0f0e0d0c0b0a09 // .ascii 16, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff' + QUAD $0x0908070605040302; QUAD $0xffff0f0e0d0c0b0a // .ascii 16, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff' + QUAD $0x0a09080706050403; QUAD $0xffffff0f0e0d0c0b // .ascii 16, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff' + QUAD $0x0b0a090807060504; QUAD $0xffffffff0f0e0d0c // .ascii 16, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff' + QUAD $0x0c0b0a0908070605; QUAD $0xffffffffff0f0e0d // .ascii 16, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff' + QUAD $0x0d0c0b0a09080706; QUAD $0xffffffffffff0f0e // .ascii 16, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff' + QUAD $0x0e0d0c0b0a090807; QUAD $0xffffffffffffff0f // .ascii 16, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff' + QUAD $0x0f0e0d0c0b0a0908; QUAD $0xffffffffffffffff // .ascii 16, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff' + + // .p2align 4, 0x00 +__SingleQuoteTab: + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000030303030755c // .asciz 8, '\\u0000\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000031303030755c // .asciz 8, '\\u0001\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000032303030755c // .asciz 8, '\\u0002\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000033303030755c // .asciz 8, '\\u0003\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000034303030755c // .asciz 8, '\\u0004\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000035303030755c // .asciz 8, '\\u0005\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000036303030755c // .asciz 8, '\\u0006\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000037303030755c // .asciz 8, '\\u0007\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000038303030755c // .asciz 8, '\\u0008\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x000000000000745c // .asciz 8, '\\t\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x0000000000006e5c // .asciz 8, '\\n\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000062303030755c // .asciz 8, '\\u000b\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000063303030755c // .asciz 8, '\\u000c\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x000000000000725c // .asciz 8, '\\r\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000065303030755c // .asciz 8, '\\u000e\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000066303030755c // .asciz 8, '\\u000f\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000030313030755c // .asciz 8, '\\u0010\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000031313030755c // .asciz 8, '\\u0011\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000032313030755c // .asciz 8, '\\u0012\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000033313030755c // .asciz 8, '\\u0013\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000034313030755c // .asciz 8, '\\u0014\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000035313030755c // .asciz 8, '\\u0015\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000036313030755c // .asciz 8, '\\u0016\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000037313030755c // .asciz 8, '\\u0017\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000038313030755c // .asciz 8, '\\u0018\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000039313030755c // .asciz 8, '\\u0019\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000061313030755c // .asciz 8, '\\u001a\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000062313030755c // .asciz 8, '\\u001b\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000063313030755c // .asciz 8, '\\u001c\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000064313030755c // .asciz 8, '\\u001d\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000065313030755c // .asciz 8, '\\u001e\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000066313030755c // .asciz 8, '\\u001f\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x000000000000225c // .asciz 8, '\\"\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x0000000000005c5c // .asciz 8, '\\\\\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +__DoubleQuoteTab: + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0030303030755c5c // .asciz 8, '\\\\u0000\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0031303030755c5c // .asciz 8, '\\\\u0001\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0032303030755c5c // .asciz 8, '\\\\u0002\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0033303030755c5c // .asciz 8, '\\\\u0003\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0034303030755c5c // .asciz 8, '\\\\u0004\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0035303030755c5c // .asciz 8, '\\\\u0005\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0036303030755c5c // .asciz 8, '\\\\u0006\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0037303030755c5c // .asciz 8, '\\\\u0007\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0038303030755c5c // .asciz 8, '\\\\u0008\x00' + QUAD $0x0000000000000003 // .quad 3 + QUAD $0x0000000000745c5c // .asciz 8, '\\\\t\x00\x00\x00\x00\x00' + QUAD $0x0000000000000003 // .quad 3 + QUAD $0x00000000006e5c5c // .asciz 8, '\\\\n\x00\x00\x00\x00\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0062303030755c5c // .asciz 8, '\\\\u000b\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0063303030755c5c // .asciz 8, '\\\\u000c\x00' + QUAD $0x0000000000000003 // .quad 3 + QUAD $0x0000000000725c5c // .asciz 8, '\\\\r\x00\x00\x00\x00\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0065303030755c5c // .asciz 8, '\\\\u000e\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0066303030755c5c // .asciz 8, '\\\\u000f\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0030313030755c5c // .asciz 8, '\\\\u0010\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0031313030755c5c // .asciz 8, '\\\\u0011\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0032313030755c5c // .asciz 8, '\\\\u0012\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0033313030755c5c // .asciz 8, '\\\\u0013\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0034313030755c5c // .asciz 8, '\\\\u0014\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0035313030755c5c // .asciz 8, '\\\\u0015\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0036313030755c5c // .asciz 8, '\\\\u0016\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0037313030755c5c // .asciz 8, '\\\\u0017\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0038313030755c5c // .asciz 8, '\\\\u0018\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0039313030755c5c // .asciz 8, '\\\\u0019\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0061313030755c5c // .asciz 8, '\\\\u001a\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0062313030755c5c // .asciz 8, '\\\\u001b\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0063313030755c5c // .asciz 8, '\\\\u001c\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0064313030755c5c // .asciz 8, '\\\\u001d\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0065313030755c5c // .asciz 8, '\\\\u001e\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0066313030755c5c // .asciz 8, '\\\\u001f\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000004 // .quad 4 + QUAD $0x00000000225c5c5c // .asciz 8, '\\\\\\"\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000004 // .quad 4 + QUAD $0x000000005c5c5c5c // .asciz 8, '\\\\\\\\\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +__EscTab: + QUAD $0x0101010101010101; QUAD $0x0101010101010101 // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01' + QUAD $0x0101010101010101; QUAD $0x0101010101010101 // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01' + QUAD $0x0000000000010000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x01 // .ascii 13, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x0000; BYTE $0x00 // .space 3, '\x00\x00\x00' + + // .p2align 4, 0x00 +__UnquoteTab: + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000220000; QUAD $0x2f00000000000000 // .ascii 16, '\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000005c00000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00' + QUAD $0x000c000000080000; QUAD $0x000a000000000000 // .ascii 16, '\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00' + LONG $0x000d0000; WORD $0xff09 // .ascii 6, '\x00\x00\r\x00\t\xff' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; WORD $0x0000 // .space 10, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +__HtmlQuoteTab: + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000036323030755c // .asciz 8, '\\u0026\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000063333030755c // .asciz 8, '\\u003c\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000065333030755c // .asciz 8, '\\u003e\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000038323032755c // .asciz 8, '\\u2028\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000039323032755c // .asciz 8, '\\u2029\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +_LSHIFT_TAB: + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000 // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000001 // .long 1 + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000001 // .long 1 + QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000001 // .long 1 + QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000002 // .long 2 + QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000002 // .long 2 + QUAD $0x0000000035323133; QUAD $0x0000000000000000 // .asciz 16, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000002 // .long 2 + QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000003 // .long 3 + QUAD $0x0000003532313837; QUAD $0x0000000000000000 // .asciz 16, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000003 // .long 3 + QUAD $0x0000353236303933; QUAD $0x0000000000000000 // .asciz 16, '390625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000003 // .long 3 + QUAD $0x0035323133353931; QUAD $0x0000000000000000 // .asciz 16, '1953125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x0035323635363739; QUAD $0x0000000000000000 // .asciz 16, '9765625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x3532313832383834; QUAD $0x0000000000000000 // .asciz 16, '48828125\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x3236303431343432; QUAD $0x0000000000000035 // .asciz 16, '244140625\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x3133303730323231; QUAD $0x0000000000003532 // .asciz 16, '1220703125\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000005 // .long 5 + QUAD $0x3635313533303136; QUAD $0x0000000000003532 // .asciz 16, '6103515625\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000005 // .long 5 + QUAD $0x3837353731353033; QUAD $0x0000000000353231 // .asciz 16, '30517578125\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000005 // .long 5 + QUAD $0x3938373835323531; QUAD $0x0000000035323630 // .asciz 16, '152587890625\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000006 // .long 6 + QUAD $0x3534393339323637; QUAD $0x0000000035323133 // .asciz 16, '762939453125\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000006 // .long 6 + QUAD $0x3237393634313833; QUAD $0x0000003532363536 // .asciz 16, '3814697265625\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000006 // .long 6 + QUAD $0x3638343337303931; QUAD $0x0000353231383233 // .asciz 16, '19073486328125\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3133343736333539; QUAD $0x0000353236303436 // .asciz 16, '95367431640625\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3531373338363734; QUAD $0x0035323133303238 // .asciz 16, '476837158203125\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3735383134383332; QUAD $0x3532363531303139 // .asciz 16, '2384185791015625' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3832393032393131; QUAD $0x3231383730353539 // .asciz 16, '1192092895507812' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000008 // .long 8 + QUAD $0x3434363430363935; QUAD $0x3236303933353737 // .asciz 16, '5960464477539062' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000008 // .long 8 + QUAD $0x3232333230383932; QUAD $0x3133353936373833 // .asciz 16, '2980232238769531' + QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000008 // .long 8 + QUAD $0x3136313130393431; QUAD $0x3536373438333931 // .asciz 16, '1490116119384765' + QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000009 // .long 9 + QUAD $0x3530383530353437; QUAD $0x3832383332393639 // .asciz 16, '7450580596923828' + QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000009 // .long 9 + QUAD $0x3230393235323733; QUAD $0x3431393136343839 // .asciz 16, '3725290298461914' + QUAD $0x0000000035323630; QUAD $0x0000000000000000 // .asciz 16, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000009 // .long 9 + QUAD $0x3135343632363831; QUAD $0x3735393033323934 // .asciz 16, '1862645149230957' + QUAD $0x0000003532313330; QUAD $0x0000000000000000 // .asciz 16, '03125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3735323233313339; QUAD $0x3538373435313634 // .asciz 16, '9313225746154785' + QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3832313636353634; QUAD $0x3239333737303337 // .asciz 16, '4656612873077392' + QUAD $0x0000353231383735; QUAD $0x0000000000000000 // .asciz 16, '578125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3436303338323332; QUAD $0x3639363833353633 // .asciz 16, '2328306436538696' + QUAD $0x0035323630393832; QUAD $0x0000000000000000 // .asciz 16, '2890625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3233353134363131; QUAD $0x3834333936323831 // .asciz 16, '1164153218269348' + QUAD $0x3532313335343431; QUAD $0x0000000000000000 // .asciz 16, '14453125\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000b // .long 11 + QUAD $0x3036363730323835; QUAD $0x3034373634333139 // .asciz 16, '5820766091346740' + QUAD $0x3532363536323237; QUAD $0x0000000000000000 // .asciz 16, '72265625\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000b // .long 11 + QUAD $0x3033383330313932; QUAD $0x3037333337363534 // .asciz 16, '2910383045673370' + QUAD $0x3231383233313633; QUAD $0x0000000000000035 // .asciz 16, '361328125\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000b // .long 11 + QUAD $0x3531393135353431; QUAD $0x3538363633383232 // .asciz 16, '1455191522836685' + QUAD $0x3630343636303831; QUAD $0x0000000000003532 // .asciz 16, '1806640625\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000c // .long 12 + QUAD $0x3637353935373237; QUAD $0x3532343338313431 // .asciz 16, '7275957614183425' + QUAD $0x3133303233333039; QUAD $0x0000000000003532 // .asciz 16, '9033203125\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000c // .long 12 + QUAD $0x3838373937333633; QUAD $0x3231373139303730 // .asciz 16, '3637978807091712' + QUAD $0x3531303636313539; QUAD $0x0000000000353236 // .asciz 16, '95166015625\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000c // .long 12 + QUAD $0x3439383938313831; QUAD $0x3635383534353330 // .asciz 16, '1818989403545856' + QUAD $0x3730303338353734; QUAD $0x0000000035323138 // .asciz 16, '475830078125\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3037343934393039; QUAD $0x3238323932373731 // .asciz 16, '9094947017729282' + QUAD $0x3933303531393733; QUAD $0x0000000035323630 // .asciz 16, '379150390625\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3533373437343534; QUAD $0x3134363436383830 // .asciz 16, '4547473508864641' + QUAD $0x3931353735393831; QUAD $0x0000003532313335 // .asciz 16, '1895751953125\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3736333733373232; QUAD $0x3032333233343435 // .asciz 16, '2273736754432320' + QUAD $0x3935373837343935; QUAD $0x0000353236353637 // .asciz 16, '59478759765625\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3338363836333131; QUAD $0x3036313631323737 // .asciz 16, '1136868377216160' + QUAD $0x3937333933373932; QUAD $0x0035323138323838 // .asciz 16, '297393798828125\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000e // .long 14 + QUAD $0x3831343334383635; QUAD $0x3130383038303638 // .asciz 16, '5684341886080801' + QUAD $0x3939383639363834; QUAD $0x0035323630343134 // .asciz 16, '486968994140625\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000e // .long 14 + QUAD $0x3930373132343832; QUAD $0x3030343034303334 // .asciz 16, '2842170943040400' + QUAD $0x3934343834333437; QUAD $0x3532313330373037 // .asciz 16, '7434844970703125' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000e // .long 14 + QUAD $0x3435383031323431; QUAD $0x3030323032353137 // .asciz 16, '1421085471520200' + QUAD $0x3432323437313733; QUAD $0x3236353135333538 // .asciz 16, '3717422485351562' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000f // .long 15 + QUAD $0x3337323435303137; QUAD $0x3130303130363735 // .asciz 16, '7105427357601001' + QUAD $0x3432313137383538; QUAD $0x3231383735373632 // .asciz 16, '8587112426757812' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000f // .long 15 + QUAD $0x3633313732353533; QUAD $0x3030353030383837 // .asciz 16, '3552713678800500' + QUAD $0x3236353533393239; QUAD $0x3630393837333331 // .asciz 16, '9293556213378906' + QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000f // .long 15 + QUAD $0x3836353336373731; QUAD $0x3035323030343933 // .asciz 16, '1776356839400250' + QUAD $0x3138373736343634; QUAD $0x3335343938363630 // .asciz 16, '4646778106689453' + QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3134383731383838; QUAD $0x3235323130303739 // .asciz 16, '8881784197001252' + QUAD $0x3530393833333233; QUAD $0x3536323734343333 // .asciz 16, '3233890533447265' + QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3032393830343434; QUAD $0x3632363030353839 // .asciz 16, '4440892098500626' + QUAD $0x3235343936313631; QUAD $0x3233363332373636 // .asciz 16, '1616945266723632' + QUAD $0x0000000035323138; QUAD $0x0000000000000000 // .asciz 16, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3036343430323232; QUAD $0x3331333035323934 // .asciz 16, '2220446049250313' + QUAD $0x3632373438303830; QUAD $0x3631383136333333 // .asciz 16, '0808472633361816' + QUAD $0x0000003532363034; QUAD $0x0000000000000000 // .asciz 16, '40625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3033323230313131; QUAD $0x3635313532363432 // .asciz 16, '1110223024625156' + QUAD $0x3336333234303435; QUAD $0x3830393038363631 // .asciz 16, '5404236316680908' + QUAD $0x0000353231333032; QUAD $0x0000000000000000 // .asciz 16, '203125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000011 // .long 17 + QUAD $0x3135313131353535; QUAD $0x3238373532313332 // .asciz 16, '5551115123125782' + QUAD $0x3531383131323037; QUAD $0x3134353430343338 // .asciz 16, '7021181583404541' + QUAD $0x0000353236353130; QUAD $0x0000000000000000 // .asciz 16, '015625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000011 // .long 17 + QUAD $0x3537353535373732; QUAD $0x3139383236353136 // .asciz 16, '2775557561562891' + QUAD $0x3730393530313533; QUAD $0x3037323230373139 // .asciz 16, '3510590791702270' + QUAD $0x0035323138373035; QUAD $0x0000000000000000 // .asciz 16, '5078125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000011 // .long 17 + QUAD $0x3738373737383331; QUAD $0x3534343138373038 // .asciz 16, '1387778780781445' + QUAD $0x3335393235353736; QUAD $0x3533313135383539 // .asciz 16, '6755295395851135' + QUAD $0x3532363039333532; QUAD $0x0000000000000000 // .asciz 16, '25390625\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000012 // .long 18 + QUAD $0x3933393838333936; QUAD $0x3832323730393330 // .asciz 16, '6938893903907228' + QUAD $0x3936373436373733; QUAD $0x3637363535323937 // .asciz 16, '3776476979255676' + QUAD $0x3532313335393632; QUAD $0x0000000000000000 // .asciz 16, '26953125\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000012 // .long 18 + QUAD $0x3936343439363433; QUAD $0x3431363335393135 // .asciz 16, '3469446951953614' + QUAD $0x3438333238383831; QUAD $0x3833383732363938 // .asciz 16, '1888238489627838' + QUAD $0x3236353637343331; QUAD $0x0000000000000035 // .asciz 16, '134765625\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000012 // .long 18 + QUAD $0x3433323734333731; QUAD $0x3730383637393537 // .asciz 16, '1734723475976807' + QUAD $0x3239313134343930; QUAD $0x3931393331383434 // .asciz 16, '0944119244813919' + QUAD $0x3138323833373630; QUAD $0x0000000000003532 // .asciz 16, '0673828125\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000013 // .long 19 + QUAD $0x3337313633373638; QUAD $0x3533303438383937 // .asciz 16, '8673617379884035' + QUAD $0x3236393530323734; QUAD $0x3539353936303432 // .asciz 16, '4720596224069595' + QUAD $0x3630343139363333; QUAD $0x0000000000003532 // .asciz 16, '3369140625\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_P10_TAB: + QUAD $0x3ff0000000000000 // .quad 0x3ff0000000000000 + QUAD $0x4024000000000000 // .quad 0x4024000000000000 + QUAD $0x4059000000000000 // .quad 0x4059000000000000 + QUAD $0x408f400000000000 // .quad 0x408f400000000000 + QUAD $0x40c3880000000000 // .quad 0x40c3880000000000 + QUAD $0x40f86a0000000000 // .quad 0x40f86a0000000000 + QUAD $0x412e848000000000 // .quad 0x412e848000000000 + QUAD $0x416312d000000000 // .quad 0x416312d000000000 + QUAD $0x4197d78400000000 // .quad 0x4197d78400000000 + QUAD $0x41cdcd6500000000 // .quad 0x41cdcd6500000000 + QUAD $0x4202a05f20000000 // .quad 0x4202a05f20000000 + QUAD $0x42374876e8000000 // .quad 0x42374876e8000000 + QUAD $0x426d1a94a2000000 // .quad 0x426d1a94a2000000 + QUAD $0x42a2309ce5400000 // .quad 0x42a2309ce5400000 + QUAD $0x42d6bcc41e900000 // .quad 0x42d6bcc41e900000 + QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000 + QUAD $0x4341c37937e08000 // .quad 0x4341c37937e08000 + QUAD $0x4376345785d8a000 // .quad 0x4376345785d8a000 + QUAD $0x43abc16d674ec800 // .quad 0x43abc16d674ec800 + QUAD $0x43e158e460913d00 // .quad 0x43e158e460913d00 + QUAD $0x4415af1d78b58c40 // .quad 0x4415af1d78b58c40 + QUAD $0x444b1ae4d6e2ef50 // .quad 0x444b1ae4d6e2ef50 + QUAD $0x4480f0cf064dd592 // .quad 0x4480f0cf064dd592 + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_LB_ff7ea7df: // _pow10_ceil_sig_f32.g + QUAD $0x81ceb32c4b43fcf5 // .quad -9093133594791772939 + QUAD $0xa2425ff75e14fc32 // .quad -6754730975062328270 + QUAD $0xcad2f7f5359a3b3f // .quad -3831727700400522433 + QUAD $0xfd87b5f28300ca0e // .quad -177973607073265138 + QUAD $0x9e74d1b791e07e49 // .quad -7028762532061872567 + QUAD $0xc612062576589ddb // .quad -4174267146649952805 + QUAD $0xf79687aed3eec552 // .quad -606147914885053102 + QUAD $0x9abe14cd44753b53 // .quad -7296371474444240045 + QUAD $0xc16d9a0095928a28 // .quad -4508778324627912152 + QUAD $0xf1c90080baf72cb2 // .quad -1024286887357502286 + QUAD $0x971da05074da7bef // .quad -7557708332239520785 + QUAD $0xbce5086492111aeb // .quad -4835449396872013077 + QUAD $0xec1e4a7db69561a6 // .quad -1432625727662628442 + QUAD $0x9392ee8e921d5d08 // .quad -7812920107430224632 + QUAD $0xb877aa3236a4b44a // .quad -5154464115860392886 + QUAD $0xe69594bec44de15c // .quad -1831394126398103204 + QUAD $0x901d7cf73ab0acda // .quad -8062150356639896358 + QUAD $0xb424dc35095cd810 // .quad -5466001927372482544 + QUAD $0xe12e13424bb40e14 // .quad -2220816390788215276 + QUAD $0x8cbccc096f5088cc // .quad -8305539271883716404 + QUAD $0xafebff0bcb24aaff // .quad -5770238071427257601 + QUAD $0xdbe6fecebdedd5bf // .quad -2601111570856684097 + QUAD $0x89705f4136b4a598 // .quad -8543223759426509416 + QUAD $0xabcc77118461cefd // .quad -6067343680855748867 + QUAD $0xd6bf94d5e57a42bd // .quad -2972493582642298179 + QUAD $0x8637bd05af6c69b6 // .quad -8775337516792518218 + QUAD $0xa7c5ac471b478424 // .quad -6357485877563259868 + QUAD $0xd1b71758e219652c // .quad -3335171328526686932 + QUAD $0x83126e978d4fdf3c // .quad -9002011107970261188 + QUAD $0xa3d70a3d70a3d70b // .quad -6640827866535438581 + QUAD $0xcccccccccccccccd // .quad -3689348814741910323 + QUAD $0x8000000000000000 // .quad -9223372036854775808 + QUAD $0xa000000000000000 // .quad -6917529027641081856 + QUAD $0xc800000000000000 // .quad -4035225266123964416 + QUAD $0xfa00000000000000 // .quad -432345564227567616 + QUAD $0x9c40000000000000 // .quad -7187745005283311616 + QUAD $0xc350000000000000 // .quad -4372995238176751616 + QUAD $0xf424000000000000 // .quad -854558029293551616 + QUAD $0x9896800000000000 // .quad -7451627795949551616 + QUAD $0xbebc200000000000 // .quad -4702848726509551616 + QUAD $0xee6b280000000000 // .quad -1266874889709551616 + QUAD $0x9502f90000000000 // .quad -7709325833709551616 + QUAD $0xba43b74000000000 // .quad -5024971273709551616 + QUAD $0xe8d4a51000000000 // .quad -1669528073709551616 + QUAD $0x9184e72a00000000 // .quad -7960984073709551616 + QUAD $0xb5e620f480000000 // .quad -5339544073709551616 + QUAD $0xe35fa931a0000000 // .quad -2062744073709551616 + QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616 + QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616 + QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616 + QUAD $0x8ac7230489e80000 // .quad -8446744073709551616 + QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616 + QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616 + QUAD $0x878678326eac9000 // .quad -8681119073709551616 + QUAD $0xa968163f0a57b400 // .quad -6239712823709551616 + QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616 + QUAD $0x84595161401484a0 // .quad -8910000909647051616 + QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616 + QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366 + QUAD $0x813f3978f8940985 // .quad -9133518327554766459 + QUAD $0xa18f07d736b90be6 // .quad -6805211891016070170 + QUAD $0xc9f2c9cd04674edf // .quad -3894828845342699809 + QUAD $0xfc6f7c4045812297 // .quad -256850038250986857 + QUAD $0x9dc5ada82b70b59e // .quad -7078060301547948642 + QUAD $0xc5371912364ce306 // .quad -4235889358507547898 + QUAD $0xf684df56c3e01bc7 // .quad -683175679707046969 + QUAD $0x9a130b963a6c115d // .quad -7344513827457986211 + QUAD $0xc097ce7bc90715b4 // .quad -4568956265895094860 + QUAD $0xf0bdc21abb48db21 // .quad -1099509313941480671 + QUAD $0x96769950b50d88f5 // .quad -7604722348854507275 + QUAD $0xbc143fa4e250eb32 // .quad -4894216917640746190 + QUAD $0xeb194f8e1ae525fe // .quad -1506085128623544834 + QUAD $0x92efd1b8d0cf37bf // .quad -7858832233030797377 + QUAD $0xb7abc627050305ae // .quad -5211854272861108818 + QUAD $0xe596b7b0c643c71a // .quad -1903131822648998118 + QUAD $0x8f7e32ce7bea5c70 // .quad -8106986416796705680 + QUAD $0xb35dbf821ae4f38c // .quad -5522047002568494196 + +TEXT ·__f32toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -56(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_f32toa: + MOVQ out+0(FP), DI + MOVSD val+8(FP), X0 + CALL ·__native_entry__+29744(SB) // _f32toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__f64toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -80(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_f64toa: + MOVQ out+0(FP), DI + MOVSD val+8(FP), X0 + CALL ·__native_entry__+496(SB) // _f64toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -312(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_get_by_path: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ path+16(FP), DX + CALL ·__native_entry__+27424(SB) // _get_by_path + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__html_escape(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -64(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_html_escape: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ dp+16(FP), DX + MOVQ dn+24(FP), CX + CALL ·__native_entry__+9968(SB) // _html_escape + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__i64toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -16(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_i64toa: + MOVQ out+0(FP), DI + MOVQ val+8(FP), SI + CALL ·__native_entry__+4112(SB) // _i64toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__lspace(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -8(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_lspace: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ off+16(FP), DX + CALL ·__native_entry__+80(SB) // _lspace + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__quote(SB), NOSPLIT | NOFRAME, $0 - 48 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -80(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_quote: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ dp+16(FP), DX + MOVQ dn+24(FP), CX + MOVQ flags+32(FP), R8 + CALL ·__native_entry__+5792(SB) // _quote + MOVQ AX, ret+40(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_array(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_array: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + MOVQ flags+24(FP), CX + CALL ·__native_entry__+20576(SB) // _skip_array + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_number(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -72(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_number: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + CALL ·__native_entry__+23920(SB) // _skip_number + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_object(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_object: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + MOVQ flags+24(FP), CX + CALL ·__native_entry__+22496(SB) // _skip_object + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_one(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_one: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + MOVQ flags+24(FP), CX + CALL ·__native_entry__+24080(SB) // _skip_one + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_one_fast(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -208(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_one_fast: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + CALL ·__native_entry__+24320(SB) // _skip_one_fast + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__u64toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -8(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_u64toa: + MOVQ out+0(FP), DI + MOVQ val+8(FP), SI + CALL ·__native_entry__+4384(SB) // _u64toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__unquote(SB), NOSPLIT | NOFRAME, $0 - 48 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_unquote: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ dp+16(FP), DX + MOVQ ep+24(FP), CX + MOVQ flags+32(FP), R8 + CALL ·__native_entry__+7488(SB) // _unquote + MOVQ AX, ret+40(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__validate_one(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_validate_one: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + CALL ·__native_entry__+24144(SB) // _validate_one + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__validate_utf8(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -48(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_validate_utf8: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + CALL ·__native_entry__+28464(SB) // _validate_utf8 + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__validate_utf8_fast(SB), NOSPLIT | NOFRAME, $0 - 16 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -24(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_validate_utf8_fast: + MOVQ s+0(FP), DI + CALL ·__native_entry__+29136(SB) // _validate_utf8_fast + MOVQ AX, ret+8(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__value(SB), NOSPLIT | NOFRAME, $0 - 48 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -368(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_value: + MOVQ s+0(FP), DI + MOVQ n+8(FP), SI + MOVQ p+16(FP), DX + MOVQ v+24(FP), CX + MOVQ flags+32(FP), R8 + CALL ·__native_entry__+14672(SB) // _value + MOVQ AX, ret+40(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vnumber(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -280(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vnumber: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + LEAQ ·__native_entry__+18320(SB), AX // _vnumber + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vsigned(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -16(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vsigned: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + LEAQ ·__native_entry__+19856(SB), AX // _vsigned + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vstring(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vstring: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + MOVQ flags+24(FP), CX + LEAQ ·__native_entry__+16864(SB), AX // _vstring + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vunsigned(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -24(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vunsigned: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + LEAQ ·__native_entry__+20208(SB), AX // _vunsigned + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_export_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx/native_export_amd64.go new file mode 100644 index 000000000..1ca7f5753 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_export_amd64.go @@ -0,0 +1,49 @@ +// 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 + +var ( + S_f64toa = _subr__f64toa + S_f32toa = _subr__f32toa + S_i64toa = _subr__i64toa + S_u64toa = _subr__u64toa + S_lspace = _subr__lspace +) + +var ( + S_quote = _subr__quote + S_unquote = _subr__unquote +) + +var ( + S_value = _subr__value + S_vstring = _subr__vstring + S_vnumber = _subr__vnumber + S_vsigned = _subr__vsigned + S_vunsigned = _subr__vunsigned +) + +var ( + S_skip_one = _subr__skip_one + S_skip_one_fast = _subr__skip_one_fast + S_skip_array = _subr__skip_array + S_skip_object = _subr__skip_object + S_skip_number = _subr__skip_number + S_get_by_path = _subr__get_by_path +) diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go new file mode 100644 index 000000000..34eaeb97c --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go @@ -0,0 +1,109 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package avx + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __native_entry__() uintptr + +var ( + _subr__f32toa = __native_entry__() + 29744 + _subr__f64toa = __native_entry__() + 496 + _subr__get_by_path = __native_entry__() + 27424 + _subr__html_escape = __native_entry__() + 9968 + _subr__i64toa = __native_entry__() + 4112 + _subr__lspace = __native_entry__() + 80 + _subr__quote = __native_entry__() + 5792 + _subr__skip_array = __native_entry__() + 20576 + _subr__skip_number = __native_entry__() + 23920 + _subr__skip_object = __native_entry__() + 22496 + _subr__skip_one = __native_entry__() + 24080 + _subr__skip_one_fast = __native_entry__() + 24320 + _subr__u64toa = __native_entry__() + 4384 + _subr__unquote = __native_entry__() + 7488 + _subr__validate_one = __native_entry__() + 24144 + _subr__validate_utf8 = __native_entry__() + 28464 + _subr__validate_utf8_fast = __native_entry__() + 29136 + _subr__value = __native_entry__() + 14672 + _subr__vnumber = __native_entry__() + 18320 + _subr__vsigned = __native_entry__() + 19856 + _subr__vstring = __native_entry__() + 16864 + _subr__vunsigned = __native_entry__() + 20208 +) + +const ( + _stack__f32toa = 56 + _stack__f64toa = 80 + _stack__get_by_path = 312 + _stack__html_escape = 64 + _stack__i64toa = 16 + _stack__lspace = 8 + _stack__quote = 80 + _stack__skip_array = 128 + _stack__skip_number = 72 + _stack__skip_object = 128 + _stack__skip_one = 128 + _stack__skip_one_fast = 208 + _stack__u64toa = 8 + _stack__unquote = 128 + _stack__validate_one = 128 + _stack__validate_utf8 = 48 + _stack__validate_utf8_fast = 24 + _stack__value = 368 + _stack__vnumber = 280 + _stack__vsigned = 16 + _stack__vstring = 128 + _stack__vunsigned = 24 +) + +var ( + _ = _subr__f32toa + _ = _subr__f64toa + _ = _subr__get_by_path + _ = _subr__html_escape + _ = _subr__i64toa + _ = _subr__lspace + _ = _subr__quote + _ = _subr__skip_array + _ = _subr__skip_number + _ = _subr__skip_object + _ = _subr__skip_one + _ = _subr__skip_one_fast + _ = _subr__u64toa + _ = _subr__unquote + _ = _subr__validate_one + _ = _subr__validate_utf8 + _ = _subr__validate_utf8_fast + _ = _subr__value + _ = _subr__vnumber + _ = _subr__vsigned + _ = _subr__vstring + _ = _subr__vunsigned +) + +const ( + _ = _stack__f32toa + _ = _stack__f64toa + _ = _stack__get_by_path + _ = _stack__html_escape + _ = _stack__i64toa + _ = _stack__lspace + _ = _stack__quote + _ = _stack__skip_array + _ = _stack__skip_number + _ = _stack__skip_object + _ = _stack__skip_one + _ = _stack__skip_one_fast + _ = _stack__u64toa + _ = _stack__unquote + _ = _stack__validate_one + _ = _stack__validate_utf8 + _ = _stack__validate_utf8_fast + _ = _stack__value + _ = _stack__vnumber + _ = _stack__vsigned + _ = _stack__vstring + _ = _stack__vunsigned +) diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go new file mode 100644 index 000000000..bf7c68683 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go @@ -0,0 +1,135 @@ +// 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 avx2 + +import ( + `unsafe` + + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __i64toa(out *byte, val int64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __u64toa(out *byte, val uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __f64toa(out *byte, val float64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __f32toa(out *byte, val float32) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __lspace(sp unsafe.Pointer, nb int, off int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vstring(s *string, p *int, v *types.JsonState, flags uint64) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vnumber(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vsigned(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vunsigned(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_one_fast(s *string, p *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_number(s *string, p *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_one(s *string, p *int, m *types.StateMachine) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __get_by_path(s *string, p *int, path *[]interface{}) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_utf8_fast(s *string) (ret int)
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.s new file mode 100644 index 000000000..198a06e92 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.s @@ -0,0 +1,16629 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__native_entry__(SB), NOSPLIT, $0 + NO_LOCAL_POINTERS + LONG $0xf9058d48; WORD $0xffff; BYTE $0xff // leaq $-7(%rip), %rax + LONG $0x24448948; BYTE $0x08 // movq %rax, $8(%rsp) + BYTE $0xc3 // retq + QUAD $0x0000000000000000; QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 5, 0x00 + +LCPI0_0: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + +LCPI0_1: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI0_2: + QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' + QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' + +LCPI0_3: + QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + + // .p2align 4, 0x00 +LCPI0_4: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + +LCPI0_5: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI0_6: + QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' + +LCPI0_7: + QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + + // .p2align 4, 0x90 +_lspace: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + LONG $0x0066840f; WORD $0x0000 // je LBB0_7, $102(%rip) + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xe183; BYTE $0x1f // andl $31, %ecx + LONG $0x005a840f; WORD $0x0000 // je LBB0_7, $90(%rip) + LONG $0x014f8d4c // leaq $1(%rdi), %r9 + LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx + QUAD $0x000100002600b849; WORD $0x0000 // movabsq $4294977024, %r8 + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB0_3: + LONG $0x0714be0f // movsbl (%rdi,%rax), %edx + WORD $0xfa83; BYTE $0x20 // cmpl $32, %edx + LONG $0x016e870f; WORD $0x0000 // ja LBB0_27, $366(%rip) + LONG $0xd0a30f49 // btq %rdx, %r8 + LONG $0x0164830f; WORD $0x0000 // jae LBB0_27, $356(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x000f840f; WORD $0x0000 // je LBB0_6, $15(%rip) + WORD $0x0144; BYTE $0xc8 // addl %r9d, %eax + WORD $0xe083; BYTE $0x1f // andl $31, %eax + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0xffcd850f; WORD $0xffff // jne LBB0_3, $-51(%rip) + +LBB0_6: + LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 + WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + +LBB0_7: + LONG $0x20fa8348 // cmpq $32, %rdx + LONG $0x006d820f; WORD $0x0000 // jb LBB0_13, $109(%rip) + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi + QUAD $0xfffffeab056ffdc5 // vmovdqa $-341(%rip), %ymm0 /* LCPI0_0(%rip) */ + QUAD $0xfffffec30d6ffdc5 // vmovdqa $-317(%rip), %ymm1 /* LCPI0_1(%rip) */ + QUAD $0xfffffedb156ffdc5 // vmovdqa $-293(%rip), %ymm2 /* LCPI0_2(%rip) */ + QUAD $0xfffffef31d6ffdc5 // vmovdqa $-269(%rip), %ymm3 /* LCPI0_3(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB0_9: + LONG $0x6f7dc1c4; BYTE $0x22 // vmovdqa (%r10), %ymm4 + LONG $0xe874ddc5 // vpcmpeqb %ymm0, %ymm4, %ymm5 + LONG $0xf174ddc5 // vpcmpeqb %ymm1, %ymm4, %ymm6 + LONG $0xeeebd5c5 // vpor %ymm6, %ymm5, %ymm5 + LONG $0xf274ddc5 // vpcmpeqb %ymm2, %ymm4, %ymm6 + LONG $0xe374ddc5 // vpcmpeqb %ymm3, %ymm4, %ymm4 + LONG $0xe6ebddc5 // vpor %ymm6, %ymm4, %ymm4 + LONG $0xe5ebddc5 // vpor %ymm5, %ymm4, %ymm4 + LONG $0xc4d7fdc5 // vpmovmskb %ymm4, %eax + WORD $0xf883; BYTE $0xff // cmpl $-1, %eax + LONG $0x00df850f; WORD $0x0000 // jne LBB0_10, $223(%rip) + LONG $0x20c28349 // addq $32, %r10 + LONG $0xe0c28348 // addq $-32, %rdx + LONG $0xe0c68348 // addq $-32, %rsi + LONG $0x1ffa8348 // cmpq $31, %rdx + LONG $0xffbc870f; WORD $0xffff // ja LBB0_9, $-68(%rip) + +LBB0_13: + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x10fa8348 // cmpq $16, %rdx + LONG $0x0074820f; WORD $0x0000 // jb LBB0_18, $116(%rip) + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi + QUAD $0xfffffeb1056ff9c5 // vmovdqa $-335(%rip), %xmm0 /* LCPI0_4(%rip) */ + QUAD $0xfffffeb90d6ff9c5 // vmovdqa $-327(%rip), %xmm1 /* LCPI0_5(%rip) */ + QUAD $0xfffffec1156ff9c5 // vmovdqa $-319(%rip), %xmm2 /* LCPI0_6(%rip) */ + QUAD $0xfffffec91d6ff9c5 // vmovdqa $-311(%rip), %xmm3 /* LCPI0_7(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB0_15: + LONG $0x6f79c1c4; BYTE $0x22 // vmovdqa (%r10), %xmm4 + LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 + LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 + LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 + LONG $0xf274d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm6 + LONG $0xe374d9c5 // vpcmpeqb %xmm3, %xmm4, %xmm4 + LONG $0xe6ebd9c5 // vpor %xmm6, %xmm4, %xmm4 + LONG $0xe5ebd9c5 // vpor %xmm5, %xmm4, %xmm4 + LONG $0xc4d7f9c5 // vpmovmskb %xmm4, %eax + LONG $0xfff88366 // cmpw $-1, %ax + LONG $0x006b850f; WORD $0x0000 // jne LBB0_16, $107(%rip) + LONG $0x10c28349 // addq $16, %r10 + LONG $0xf0c28348 // addq $-16, %rdx + LONG $0xf0c68348 // addq $-16, %rsi + LONG $0x0ffa8348 // cmpq $15, %rdx + LONG $0xffbb870f; WORD $0xffff // ja LBB0_15, $-69(%rip) + +LBB0_18: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0037840f; WORD $0x0000 // je LBB0_25, $55(%rip) + LONG $0x12048d4d // leaq (%r10,%rdx), %r8 + WORD $0xc031 // xorl %eax, %eax + QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 + +LBB0_20: + LONG $0x34be0f41; BYTE $0x02 // movsbl (%r10,%rax), %esi + WORD $0xfe83; BYTE $0x20 // cmpl $32, %esi + LONG $0x0036870f; WORD $0x0000 // ja LBB0_22, $54(%rip) + LONG $0xf1a30f49 // btq %rsi, %r9 + LONG $0x002c830f; WORD $0x0000 // jae LBB0_22, $44(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx + LONG $0xffdc850f; WORD $0xffff // jne LBB0_20, $-36(%rip) + WORD $0x894d; BYTE $0xc2 // movq %r8, %r10 + +LBB0_25: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + +LBB0_26: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + +LBB0_27: + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB0_10: + WORD $0xf8c5; BYTE $0x77 // vzeroupper + +LBB0_11: + WORD $0xd0f7 // notl %eax + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax + WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB0_16: + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0xffffeee9; BYTE $0xff // jmp LBB0_11, $-18(%rip) + +LBB0_22: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + LONG $0xffffdbe9; BYTE $0xff // jmp LBB0_26, $-37(%rip) + WORD $0x0000; BYTE $0x00 // .p2align 5, 0x00 + +LCPI1_0: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x00 +LCPI1_1: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x90 +_f64toa: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + LONG $0x7ef9e1c4; BYTE $0xc2 // vmovq %xmm0, %rdx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x34e8c148 // shrq $52, %rax + LONG $0x0007ff25; BYTE $0x00 // andl $2047, %eax + LONG $0x0007ff3d; BYTE $0x00 // cmpl $2047, %eax + LONG $0x0c1e840f; WORD $0x0000 // je LBB1_1, $3102(%rip) + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 + LONG $0x3fedc149 // shrq $63, %r13 + LONG $0x2f3c8d4e // leaq (%rdi,%r13), %r15 + QUAD $0x00000000550c8d48 // leaq (,%rdx,2), %rcx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x01f5840f; WORD $0x0000 // je LBB1_3, $501(%rip) + QUAD $0xffffffffffffbf48; WORD $0x000f // movabsq $4503599627370495, %rdi + WORD $0x2148; BYTE $0xfa // andq %rdi, %rdx + WORD $0xc085 // testl %eax, %eax + LONG $0xd0758948 // movq %rsi, $-48(%rbp) + LONG $0x0bea840f; WORD $0x0000 // je LBB1_5, $3050(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0x0948; BYTE $0xd7 // orq %rdx, %rdi + LONG $0xfbcdb08d; WORD $0xffff // leal $-1075(%rax), %esi + LONG $0xfc01888d; WORD $0xffff // leal $-1023(%rax), %ecx + WORD $0xf983; BYTE $0x34 // cmpl $52, %ecx + LONG $0x001d870f; WORD $0x0000 // ja LBB1_6, $29(%rip) + LONG $0x000433b9; BYTE $0x00 // movl $1075, %ecx + WORD $0xc129 // subl %eax, %ecx + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx + WORD $0xf748; BYTE $0xd3 // notq %rbx + WORD $0x8548; BYTE $0xdf // testq %rbx, %rdi + LONG $0x0421840f; WORD $0x0000 // je LBB1_11, $1057(%rip) + +LBB1_6: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + WORD $0x940f; BYTE $0xc1 // sete %cl + WORD $0xf883; BYTE $0x02 // cmpl $2, %eax + WORD $0x930f; BYTE $0xc0 // setae %al + WORD $0xc820 // andb %cl, %al + QUAD $0x00000000bd0c8d4c // leaq (,%rdi,4), %r9 + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + LONG $0xb81c8d48 // leaq (%rax,%rdi,4), %rbx + LONG $0xfec38348 // addq $-2, %rbx + LONG $0x4413ce69; WORD $0x0013 // imull $1262611, %esi, %ecx + LONG $0x01918d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rcx), %r10d + WORD $0xc084 // testb %al, %al + LONG $0xd1440f44 // cmovel %ecx, %r10d + QUAD $0x00000002bd048d4c // leaq $2(,%rdi,4), %r8 + LONG $0x16fac141 // sarl $22, %r10d + LONG $0xb1ca6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r10d, %ecx + WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx + WORD $0xf101 // addl %esi, %ecx + LONG $0x000124b8; BYTE $0x00 // movl $292, %eax + WORD $0x2944; BYTE $0xd0 // subl %r10d, %eax + LONG $0x04e0c148 // shlq $4, %rax + LONG $0x44158d48; WORD $0x00cc; BYTE $0x00 // leaq $52292(%rip), %rdx /* _pow10_ceil_sig.g(%rip) */ + LONG $0x101c8b4c // movq (%rax,%rdx), %r11 + LONG $0x10748b4c; BYTE $0x08 // movq $8(%rax,%rdx), %r14 + WORD $0xc1fe // incb %cl + WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0x00d28348 // adcq $0, %rdx + WORD $0xf631 // xorl %esi, %esi + LONG $0xfffea948; WORD $0xffff // testq $-2, %rax + LONG $0xc6950f40 // setne %sil + WORD $0x0948; BYTE $0xd6 // orq %rdx, %rsi + WORD $0xd349; BYTE $0xe1 // shlq %cl, %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0x00d18349 // adcq $0, %r9 + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xfffea948; WORD $0xffff // testq $-2, %rax + WORD $0x950f; BYTE $0xc3 // setne %bl + WORD $0x094c; BYTE $0xcb // orq %r9, %rbx + WORD $0xd349; BYTE $0xe0 // shlq %cl, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0x00d28348 // adcq $0, %rdx + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xfffea948; WORD $0xffff // testq $-2, %rax + WORD $0x950f; BYTE $0xc1 // setne %cl + WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx + WORD $0xe783; BYTE $0x01 // andl $1, %edi + WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi + WORD $0x2948; BYTE $0xf9 // subq %rdi, %rcx + LONG $0x28fb8348 // cmpq $40, %rbx + LONG $0x0043820f; WORD $0x0000 // jb LBB1_28, $67(%rip) + QUAD $0xcccccccccccdba48; WORD $0xcccc // movabsq $-3689348814741910323, %rdx + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xe2 // mulq %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0x05efc148 // shrq $5, %rdi + QUAD $0x00000000fd048d48 // leaq (,%rdi,8), %rax + LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xc0970f41 // seta %r8b + LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx + LONG $0x28c28348 // addq $40, %rdx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xca // cmpq %rcx, %rdx + WORD $0x960f; BYTE $0xc2 // setbe %dl + WORD $0x3841; BYTE $0xd0 // cmpb %dl, %r8b + LONG $0x0134840f; WORD $0x0000 // je LBB1_8, $308(%rip) + +LBB1_28: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + LONG $0x02e8c149 // shrq $2, %r8 + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + LONG $0xfce28348 // andq $-4, %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xc7970f40 // seta %dil + LONG $0x04728d48 // leaq $4(%rdx), %rsi + WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi + WORD $0x960f; BYTE $0xc0 // setbe %al + WORD $0x3040; BYTE $0xf8 // xorb %dil, %al + LONG $0x0055840f; WORD $0x0000 // je LBB1_29, $85(%rip) + LONG $0x02ca8348 // orq $2, %rdx + LONG $0x000001bf; BYTE $0x00 // movl $1, %edi + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0x000e870f; WORD $0x0000 // ja LBB1_32, $14(%rip) + WORD $0x940f; BYTE $0xc0 // sete %al + LONG $0x02e9c041 // shrb $2, %r9b + WORD $0x2041; BYTE $0xc1 // andb %al, %r9b + LONG $0xf9b60f41 // movzbl %r9b, %edi + +LBB1_32: + WORD $0x014c; BYTE $0xc7 // addq %r8, %rdi + QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 + QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x003c870f; WORD $0x0000 // ja LBB1_34, $60(%rip) + LONG $0x0000ece9; BYTE $0x00 // jmp LBB1_40, $236(%rip) + +LBB1_3: + LONG $0x3007c641 // movb $48, (%r15) + WORD $0x2941; BYTE $0xf7 // subl %esi, %r15d + WORD $0xff41; BYTE $0xc7 // incl %r15d + WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx + LONG $0x0009e1e9; BYTE $0x00 // jmp LBB1_123, $2529(%rip) + +LBB1_29: + WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx + LONG $0xffd88349 // sbbq $-1, %r8 + WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi + QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 + QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00b5860f; WORD $0x0000 // jbe LBB1_40, $181(%rip) + +LBB1_34: + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0be8c148 // shrq $11, %rax + LONG $0x00000bba; BYTE $0x00 // movl $11, %edx + LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax + LONG $0x0136820f; WORD $0x0000 // jb LBB1_49, $310(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0ce8c148 // shrq $12, %rax + LONG $0x00000cba; BYTE $0x00 // movl $12, %edx + LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax + LONG $0x011e820f; WORD $0x0000 // jb LBB1_49, $286(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0de8c148 // shrq $13, %rax + LONG $0x00000dba; BYTE $0x00 // movl $13, %edx + LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax + LONG $0x0106820f; WORD $0x0000 // jb LBB1_49, $262(%rip) + LONG $0x00000eba; BYTE $0x00 // movl $14, %edx + QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00ee820f; WORD $0x0000 // jb LBB1_49, $238(%rip) + LONG $0x00000fba; BYTE $0x00 // movl $15, %edx + QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00d6820f; WORD $0x0000 // jb LBB1_49, $214(%rip) + QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax + WORD $0xd231 // xorl %edx, %edx + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + WORD $0x920f; BYTE $0xc2 // setb %dl + WORD $0xf283; BYTE $0x11 // xorl $17, %edx + LONG $0x0000bce9; BYTE $0x00 // jmp LBB1_49, $188(%rip) + +LBB1_8: + WORD $0xd088 // movb %dl, %al + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + WORD $0xff41; BYTE $0xc2 // incl %r10d + QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 + QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0xff4b870f; WORD $0xffff // ja LBB1_34, $-181(%rip) + +LBB1_40: + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + LONG $0x0aff8348 // cmpq $10, %rdi + LONG $0x008a820f; WORD $0x0000 // jb LBB1_49, $138(%rip) + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + LONG $0x64ff8348 // cmpq $100, %rdi + LONG $0x007b820f; WORD $0x0000 // jb LBB1_49, $123(%rip) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi + LONG $0x0069820f; WORD $0x0000 // jb LBB1_49, $105(%rip) + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi + LONG $0x0057820f; WORD $0x0000 // jb LBB1_49, $87(%rip) + LONG $0x000005ba; BYTE $0x00 // movl $5, %edx + LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi + LONG $0x0045820f; WORD $0x0000 // jb LBB1_49, $69(%rip) + LONG $0x000006ba; BYTE $0x00 // movl $6, %edx + LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi + LONG $0x0033820f; WORD $0x0000 // jb LBB1_49, $51(%rip) + LONG $0x000007ba; BYTE $0x00 // movl $7, %edx + LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi + LONG $0x0021820f; WORD $0x0000 // jb LBB1_49, $33(%rip) + LONG $0x000008ba; BYTE $0x00 // movl $8, %edx + LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi + LONG $0x000f820f; WORD $0x0000 // jb LBB1_49, $15(%rip) + LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + WORD $0xda83; BYTE $0x00 // sbbl $0, %edx + +LBB1_49: + LONG $0x12348d46 // leal (%rdx,%r10), %r14d + LONG $0x12048d42 // leal (%rdx,%r10), %eax + WORD $0xc083; BYTE $0xea // addl $-22, %eax + WORD $0xf883; BYTE $0xe4 // cmpl $-28, %eax + LONG $0x00a4870f; WORD $0x0000 // ja LBB1_62, $164(%rip) + LONG $0x01678d4d // leaq $1(%r15), %r12 + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0x0090eae8; BYTE $0x00 // callq _format_significand, $37098(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + WORD $0x294c; BYTE $0xd0 // subq %r10, %rax + WORD $0x294c; BYTE $0xe8 // subq %r13, %rax + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_51: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x30ff7b80 // cmpb $48, $-1(%rbx) + LONG $0xff5b8d48 // leaq $-1(%rbx), %rbx + LONG $0xffef840f; WORD $0xffff // je LBB1_51, $-17(%rip) + LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx + WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x00088c0f; WORD $0x0000 // jl LBB1_54, $8(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x2404c641; BYTE $0x2e // movb $46, (%r12) + +LBB1_54: + WORD $0x03c6; BYTE $0x65 // movb $101, (%rbx) + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x011d8e0f; WORD $0x0000 // jle LBB1_55, $285(%rip) + WORD $0xff41; BYTE $0xce // decl %r14d + LONG $0x2b0143c6 // movb $43, $1(%rbx) + WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0x011f820f; WORD $0x0000 // jb LBB1_59, $287(%rip) + +LBB1_58: + WORD $0xc189 // movl %eax, %ecx + LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx + LONG $0xd1af0f48 // imulq %rcx, %rdx + LONG $0x23eac148 // shrq $35, %rdx + WORD $0x0c8d; BYTE $0x12 // leal (%rdx,%rdx), %ecx + WORD $0x0c8d; BYTE $0x89 // leal (%rcx,%rcx,4), %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0x080d8d48; WORD $0x00c8; BYTE $0x00 // leaq $51208(%rip), %rcx /* _Digits(%rip) */ + LONG $0x510cb70f // movzwl (%rcx,%rdx,2), %ecx + LONG $0x024b8966 // movw %cx, $2(%rbx) + WORD $0x300c // orb $48, %al + WORD $0x4388; BYTE $0x04 // movb %al, $4(%rbx) + LONG $0x05c38348 // addq $5, %rbx + LONG $0x0007b3e9; BYTE $0x00 // jmp LBB1_122, $1971(%rip) + +LBB1_62: + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0105880f; WORD $0x0000 // js LBB1_63, $261(%rip) + WORD $0x8945; BYTE $0xf6 // movl %r14d, %r14d + LONG $0x371c8d4b // leaq (%r15,%r14), %rbx + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x0007dae8; BYTE $0x00 // callq _format_integer, $2010(%rip) + WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax + LONG $0x0154830f; WORD $0x0000 // jae LBB1_103, $340(%rip) + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + WORD $0x014d; BYTE $0xd5 // addq %r10, %r13 + WORD $0x014d; BYTE $0xf5 // addq %r14, %r13 + WORD $0x2949; BYTE $0xc5 // subq %rax, %r13 + LONG $0x10fd8349 // cmpq $16, %r13 + LONG $0x01f1830f; WORD $0x0000 // jae LBB1_105, $497(%rip) + +LBB1_120: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + LONG $0x000372e9; BYTE $0x00 // jmp LBB1_121, $882(%rip) + +LBB1_11: + WORD $0xd348; BYTE $0xef // shrq %cl, %rdi + QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq $8589934464, %rax + LONG $0xe47f0548; WORD $0x540b // addq $1410065535, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x0130860f; WORD $0x0000 // jbe LBB1_17, $304(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0be8c148 // shrq $11, %rax + LONG $0x00000bba; BYTE $0x00 // movl $11, %edx + LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax + LONG $0x01a2820f; WORD $0x0000 // jb LBB1_27, $418(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0ce8c148 // shrq $12, %rax + LONG $0x00000cba; BYTE $0x00 // movl $12, %edx + LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax + LONG $0x018a820f; WORD $0x0000 // jb LBB1_27, $394(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0de8c148 // shrq $13, %rax + LONG $0x00000dba; BYTE $0x00 // movl $13, %edx + LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax + LONG $0x0172820f; WORD $0x0000 // jb LBB1_27, $370(%rip) + LONG $0x00000eba; BYTE $0x00 // movl $14, %edx + QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x015a820f; WORD $0x0000 // jb LBB1_27, $346(%rip) + QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x000010ba; BYTE $0x00 // movl $16, %edx + +LBB1_26: + WORD $0xda83; BYTE $0x00 // sbbl $0, %edx + LONG $0x000140e9; BYTE $0x00 // jmp LBB1_27, $320(%rip) + +LBB1_55: + LONG $0x2d0143c6 // movb $45, $1(%rbx) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x2944; BYTE $0xf0 // subl %r14d, %eax + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0xfee1830f; WORD $0xffff // jae LBB1_58, $-287(%rip) + +LBB1_59: + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x008a820f; WORD $0x0000 // jb LBB1_61, $138(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0xf50d8d48; WORD $0x00c6; BYTE $0x00 // leaq $50933(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x02438966 // movw %ax, $2(%rbx) + LONG $0x04c38348 // addq $4, %rbx + LONG $0x0006a5e9; BYTE $0x00 // jmp LBB1_122, $1701(%rip) + +LBB1_63: + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x03ca8f0f; WORD $0x0000 // jg LBB1_76, $970(%rip) + LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) + LONG $0x02c78349 // addq $2, %r15 + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x03b7890f; WORD $0x0000 // jns LBB1_76, $951(%rip) + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0xf741; BYTE $0xd0 // notl %r8d + WORD $0x2945; BYTE $0xd0 // subl %r10d, %r8d + WORD $0xc031 // xorl %eax, %eax + LONG $0x7ff88341 // cmpl $127, %r8d + LONG $0x038e820f; WORD $0x0000 // jb LBB1_74, $910(%rip) + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x214c; BYTE $0xe0 // andq %r12, %rax + LONG $0x80488d48 // leaq $-128(%rax), %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0x07eec148 // shrq $7, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8941; BYTE $0xf1 // movl %esi, %r9d + LONG $0x03e18341 // andl $3, %r9d + LONG $0x80f98148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rcx + LONG $0x0264830f; WORD $0x0000 // jae LBB1_68, $612(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x000307e9; BYTE $0x00 // jmp LBB1_70, $775(%rip) + +LBB1_103: + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x000635e9; BYTE $0x00 // jmp LBB1_122, $1589(%rip) + +LBB1_61: + WORD $0x3004 // addb $48, %al + WORD $0x4388; BYTE $0x02 // movb %al, $2(%rbx) + LONG $0x03c38348 // addq $3, %rbx + LONG $0x000627e9; BYTE $0x00 // jmp LBB1_122, $1575(%rip) + +LBB1_17: + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + LONG $0x0aff8348 // cmpq $10, %rdi + LONG $0x007b820f; WORD $0x0000 // jb LBB1_27, $123(%rip) + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + LONG $0x64ff8348 // cmpq $100, %rdi + LONG $0x006c820f; WORD $0x0000 // jb LBB1_27, $108(%rip) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi + LONG $0x005a820f; WORD $0x0000 // jb LBB1_27, $90(%rip) + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi + LONG $0x0048820f; WORD $0x0000 // jb LBB1_27, $72(%rip) + LONG $0x000005ba; BYTE $0x00 // movl $5, %edx + LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi + LONG $0x0036820f; WORD $0x0000 // jb LBB1_27, $54(%rip) + LONG $0x000006ba; BYTE $0x00 // movl $6, %edx + LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi + LONG $0x0024820f; WORD $0x0000 // jb LBB1_27, $36(%rip) + LONG $0x000007ba; BYTE $0x00 // movl $7, %edx + LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi + LONG $0x0012820f; WORD $0x0000 // jb LBB1_27, $18(%rip) + LONG $0x000008ba; BYTE $0x00 // movl $8, %edx + LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi + LONG $0x05c8830f; WORD $0x0000 // jae LBB1_25, $1480(%rip) + +LBB1_27: + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x0005d4e8; BYTE $0x00 // callq _format_integer, $1492(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + WORD $0x5d2b; BYTE $0xd0 // subl $-48(%rbp), %ebx + LONG $0x00058de9; BYTE $0x00 // jmp LBB1_123, $1421(%rip) + +LBB1_105: + LONG $0x80fd8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r13 + LONG $0x0007830f; WORD $0x0000 // jae LBB1_110, $7(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x00013ce9; BYTE $0x00 // jmp LBB1_107, $316(%rip) + +LBB1_110: + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + LONG $0x80e18348 // andq $-128, %rcx + LONG $0x80798d48 // leaq $-128(%rcx), %rdi + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0x07eec148 // shrq $7, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xf289 // movl %esi, %edx + WORD $0xe283; BYTE $0x03 // andl $3, %edx + LONG $0x80ff8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdi + LONG $0x0007830f; WORD $0x0000 // jae LBB1_112, $7(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x0000abe9; BYTE $0x00 // jmp LBB1_114, $171(%rip) + +LBB1_112: + LONG $0xfce68348 // andq $-4, %rsi + WORD $0xff31 // xorl %edi, %edi + QUAD $0xfffff8d9056ffdc5 // vmovdqa $-1831(%rip), %ymm0 /* LCPI1_0(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_113: + LONG $0x047ffec5; BYTE $0x38 // vmovdqu %ymm0, (%rax,%rdi) + LONG $0x447ffec5; WORD $0x2038 // vmovdqu %ymm0, $32(%rax,%rdi) + LONG $0x447ffec5; WORD $0x4038 // vmovdqu %ymm0, $64(%rax,%rdi) + LONG $0x447ffec5; WORD $0x6038 // vmovdqu %ymm0, $96(%rax,%rdi) + QUAD $0x00008038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $128(%rax,%rdi) + QUAD $0x0000a038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $160(%rax,%rdi) + QUAD $0x0000c038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $192(%rax,%rdi) + QUAD $0x0000e038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $224(%rax,%rdi) + QUAD $0x00010038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $256(%rax,%rdi) + QUAD $0x00012038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $288(%rax,%rdi) + QUAD $0x00014038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $320(%rax,%rdi) + QUAD $0x00016038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $352(%rax,%rdi) + QUAD $0x00018038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $384(%rax,%rdi) + QUAD $0x0001a038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $416(%rax,%rdi) + QUAD $0x0001c038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $448(%rax,%rdi) + QUAD $0x0001e038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $480(%rax,%rdi) + LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq $512, %rdi + LONG $0xfcc68348 // addq $-4, %rsi + LONG $0xff6c850f; WORD $0xffff // jne LBB1_113, $-148(%rip) + +LBB1_114: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0047840f; WORD $0x0000 // je LBB1_117, $71(%rip) + LONG $0x07348d48 // leaq (%rdi,%rax), %rsi + LONG $0x60c68348 // addq $96, %rsi + LONG $0x07e2c148 // shlq $7, %rdx + WORD $0xff31 // xorl %edi, %edi + QUAD $0xfffff81d056ffdc5 // vmovdqa $-2019(%rip), %ymm0 /* LCPI1_0(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_116: + LONG $0x447ffec5; WORD $0xa03e // vmovdqu %ymm0, $-96(%rsi,%rdi) + LONG $0x447ffec5; WORD $0xc03e // vmovdqu %ymm0, $-64(%rsi,%rdi) + LONG $0x447ffec5; WORD $0xe03e // vmovdqu %ymm0, $-32(%rsi,%rdi) + LONG $0x047ffec5; BYTE $0x3e // vmovdqu %ymm0, (%rsi,%rdi) + LONG $0x80ef8348 // subq $-128, %rdi + WORD $0x3948; BYTE $0xfa // cmpq %rdi, %rdx + LONG $0xffdc850f; WORD $0xffff // jne LBB1_116, $-36(%rip) + +LBB1_117: + WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 + LONG $0x0444840f; WORD $0x0000 // je LBB1_122, $1092(%rip) + LONG $0x70c5f641 // testb $112, %r13b + LONG $0x004d840f; WORD $0x0000 // je LBB1_119, $77(%rip) + +LBB1_107: + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + LONG $0xf0e68348 // andq $-16, %rsi + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x0148; BYTE $0xf2 // addq %rsi, %rdx + QUAD $0xfffff7e4056ff9c5 // vmovdqa $-2076(%rip), %xmm0 /* LCPI1_1(%rip) */ + LONG $0x90909090 // .p2align 4, 0x90 + +LBB1_108: + LONG $0x047ffac5; BYTE $0x08 // vmovdqu %xmm0, (%rax,%rcx) + LONG $0x10c18348 // addq $16, %rcx + WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi + LONG $0xffee850f; WORD $0xffff // jne LBB1_108, $-18(%rip) + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0x0406840f; WORD $0x0000 // je LBB1_122, $1030(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_121: + WORD $0x02c6; BYTE $0x30 // movb $48, (%rdx) + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3948; BYTE $0xda // cmpq %rbx, %rdx + LONG $0xfff1820f; WORD $0xffff // jb LBB1_121, $-15(%rip) + LONG $0x0003ede9; BYTE $0x00 // jmp LBB1_122, $1005(%rip) + +LBB1_119: + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0xfffc6ae9; BYTE $0xff // jmp LBB1_120, $-918(%rip) + +LBB1_68: + LONG $0xfce68348 // andq $-4, %rsi + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x2a1c8d4b // leaq (%r10,%r13), %rbx + LONG $0xe2c38148; WORD $0x0001; BYTE $0x00 // addq $482, %rbx + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0xfffff767056ffdc5 // vmovdqa $-2201(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_69: + QUAD $0xfffe200b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rbx,%rcx) + QUAD $0xfffe400b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rbx,%rcx) + QUAD $0xfffe600b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rbx,%rcx) + QUAD $0xfffe800b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rbx,%rcx) + QUAD $0xfffea00b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rbx,%rcx) + QUAD $0xfffec00b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rbx,%rcx) + QUAD $0xfffee00b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rbx,%rcx) + QUAD $0xffff000b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rbx,%rcx) + QUAD $0xffff200b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rbx,%rcx) + QUAD $0xffff400b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rbx,%rcx) + QUAD $0xffff600b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rbx,%rcx) + LONG $0x447ffec5; WORD $0x800b // vmovdqu %ymm0, $-128(%rbx,%rcx) + LONG $0x447ffec5; WORD $0xa00b // vmovdqu %ymm0, $-96(%rbx,%rcx) + LONG $0x447ffec5; WORD $0xc00b // vmovdqu %ymm0, $-64(%rbx,%rcx) + LONG $0x447ffec5; WORD $0xe00b // vmovdqu %ymm0, $-32(%rbx,%rcx) + LONG $0x047ffec5; BYTE $0x0b // vmovdqu %ymm0, (%rbx,%rcx) + LONG $0x00c18148; WORD $0x0002; BYTE $0x00 // addq $512, %rcx + LONG $0xfcc68348 // addq $-4, %rsi + LONG $0xff6f850f; WORD $0xffff // jne LBB1_69, $-145(%rip) + +LBB1_70: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x003c840f; WORD $0x0000 // je LBB1_73, $60(%rip) + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x62c18348 // addq $98, %rcx + LONG $0x07e1c149 // shlq $7, %r9 + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff6b5056ffdc5 // vmovdqa $-2379(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_72: + LONG $0x447ffec5; WORD $0xa031 // vmovdqu %ymm0, $-96(%rcx,%rsi) + LONG $0x447ffec5; WORD $0xc031 // vmovdqu %ymm0, $-64(%rcx,%rsi) + LONG $0x447ffec5; WORD $0xe031 // vmovdqu %ymm0, $-32(%rcx,%rsi) + LONG $0x047ffec5; BYTE $0x31 // vmovdqu %ymm0, (%rcx,%rsi) + LONG $0x80ee8348 // subq $-128, %rsi + WORD $0x3949; BYTE $0xf1 // cmpq %rsi, %r9 + LONG $0xffdc850f; WORD $0xffff // jne LBB1_72, $-36(%rip) + +LBB1_73: + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0014840f; WORD $0x0000 // je LBB1_76, $20(%rip) + +LBB1_74: + WORD $0x0144; BYTE $0xf0 // addl %r14d, %eax + WORD $0xd8f7 // negl %eax + + // .p2align 4, 0x90 +LBB1_75: + LONG $0x3007c641 // movb $48, (%r15) + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xc8ff // decl %eax + LONG $0xfff1850f; WORD $0xffff // jne LBB1_75, $-15(%rip) + +LBB1_76: + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x008b66e8; BYTE $0x00 // callq _format_significand, $35686(%rip) + WORD $0xc389 // movl %eax, %ebx + WORD $0x2844; BYTE $0xfb // subb %r15b, %bl + WORD $0x2844; BYTE $0xf3 // subb %r14b, %bl + LONG $0x3e2c8d47 // leal (%r14,%r15), %r13d + WORD $0x2941; BYTE $0xc5 // subl %eax, %r13d + LONG $0xff458d45 // leal $-1(%r13), %r8d + LONG $0xfe7d8d41 // leal $-2(%r13), %edi + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_77: + WORD $0xda89 // movl %ebx, %edx + WORD $0x5a8d; BYTE $0x03 // leal $3(%rdx), %ebx + WORD $0xc7ff // incl %edi + LONG $0xff087c80; BYTE $0x30 // cmpb $48, $-1(%rax,%rcx) + LONG $0xff498d48 // leaq $-1(%rcx), %rcx + LONG $0xffea840f; WORD $0xffff // je LBB1_77, $-22(%rip) + LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x02778e0f; WORD $0x0000 // jle LBB1_122, $631(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xfe // subl %r15d, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0xc6ff // incl %esi + WORD $0x3941; BYTE $0xf6 // cmpl %esi, %r14d + LONG $0x00308d0f; WORD $0x0000 // jge LBB1_80, $48(%rip) + WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d + WORD $0x2945; BYTE $0xf1 // subl %r14d, %r9d + WORD $0x2945; BYTE $0xf9 // subl %r15d, %r9d + WORD $0xff41; BYTE $0xc1 // incl %r9d + LONG $0x093c8d49 // leaq (%r9,%rcx), %rdi + WORD $0xff85 // testl %edi, %edi + LONG $0x00e48e0f; WORD $0x0000 // jle LBB1_99, $228(%rip) + WORD $0x8941; BYTE $0xf8 // movl %edi, %r8d + LONG $0xff588d49 // leaq $-1(%r8), %rbx + LONG $0x03fb8348 // cmpq $3, %rbx + LONG $0x006c830f; WORD $0x0000 // jae LBB1_100, $108(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x000090e9; BYTE $0x00 // jmp LBB1_96, $144(%rip) + +LBB1_80: + WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d + WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x02268e0f; WORD $0x0000 // jle LBB1_122, $550(%rip) + WORD $0x0145; BYTE $0xfe // addl %r15d, %r14d + WORD $0x2941; BYTE $0xc6 // subl %eax, %r14d + LONG $0xfec68341 // addl $-2, %r14d + WORD $0x2949; BYTE $0xce // subq %rcx, %r14 + WORD $0xd231 // xorl %edx, %edx + LONG $0x7ffe8341 // cmpl $127, %r14d + LONG $0x01fc820f; WORD $0x0000 // jb LBB1_91, $508(%rip) + LONG $0xfec58341 // addl $-2, %r13d + WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 + WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x214d; BYTE $0xc4 // andq %r8, %r12 + WORD $0x8941; BYTE $0xf9 // movl %edi, %r9d + WORD $0xff49; BYTE $0xc1 // incq %r9 + LONG $0x80e18349 // andq $-128, %r9 + LONG $0x24548d49; BYTE $0x80 // leaq $-128(%r12), %rdx + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + LONG $0x07eac149 // shrq $7, %r10 + WORD $0xff49; BYTE $0xc2 // incq %r10 + LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdx + LONG $0x0083830f; WORD $0x0000 // jae LBB1_84, $131(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x000138e9; BYTE $0x00 // jmp LBB1_86, $312(%rip) + +LBB1_100: + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + LONG $0xfce18341 // andl $-4, %r9d + WORD $0xf749; BYTE $0xd9 // negq %r9 + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_101: + LONG $0x183c8d48 // leaq (%rax,%rbx), %rdi + LONG $0xfd39748b // movl $-3(%rcx,%rdi), %esi + LONG $0xfe397489 // movl %esi, $-2(%rcx,%rdi) + LONG $0xfcc38348 // addq $-4, %rbx + WORD $0x3949; BYTE $0xd9 // cmpq %rbx, %r9 + LONG $0xffe7850f; WORD $0xffff // jne LBB1_101, $-25(%rip) + WORD $0xf748; BYTE $0xdb // negq %rbx + +LBB1_96: + LONG $0x03c0f641 // testb $3, %r8b + LONG $0x0032840f; WORD $0x0000 // je LBB1_99, $50(%rip) + LONG $0xc2b60f44 // movzbl %dl, %r8d + LONG $0x03e08341 // andl $3, %r8d + WORD $0xf749; BYTE $0xd8 // negq %r8 + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x2948; BYTE $0xde // subq %rbx, %rsi + WORD $0xff31 // xorl %edi, %edi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_98: + LONG $0x3e1c8d48 // leaq (%rsi,%rdi), %rbx + LONG $0x1914b60f // movzbl (%rcx,%rbx), %edx + LONG $0x01195488 // movb %dl, $1(%rcx,%rbx) + WORD $0xff48; BYTE $0xcf // decq %rdi + WORD $0x3949; BYTE $0xf8 // cmpq %rdi, %r8 + LONG $0xffe8850f; WORD $0xffff // jne LBB1_98, $-24(%rip) + +LBB1_99: + WORD $0x8944; BYTE $0xf2 // movl %r14d, %edx + LONG $0x1704c641; BYTE $0x2e // movb $46, (%r15,%rdx) + LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx + LONG $0x02c38348 // addq $2, %rbx + LONG $0x000154e9; BYTE $0x00 // jmp LBB1_122, $340(%rip) + +LBB1_84: + WORD $0x8944; BYTE $0xeb // movl %r13d, %ebx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x80e38348 // andq $-128, %rbx + LONG $0x80c38348 // addq $-128, %rbx + LONG $0x07ebc148 // shrq $7, %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfce38348 // andq $-4, %rbx + WORD $0xff31 // xorl %edi, %edi + QUAD $0xfffff4d0056ffdc5 // vmovdqa $-2864(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_85: + LONG $0x38148d48 // leaq (%rax,%rdi), %rdx + LONG $0x447ffec5; WORD $0x0111 // vmovdqu %ymm0, $1(%rcx,%rdx) + LONG $0x447ffec5; WORD $0x2111 // vmovdqu %ymm0, $33(%rcx,%rdx) + LONG $0x447ffec5; WORD $0x4111 // vmovdqu %ymm0, $65(%rcx,%rdx) + LONG $0x447ffec5; WORD $0x6111 // vmovdqu %ymm0, $97(%rcx,%rdx) + QUAD $0x00008111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $129(%rcx,%rdx) + QUAD $0x0000a111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $161(%rcx,%rdx) + QUAD $0x0000c111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $193(%rcx,%rdx) + QUAD $0x0000e111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $225(%rcx,%rdx) + QUAD $0x00010111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $257(%rcx,%rdx) + QUAD $0x00012111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $289(%rcx,%rdx) + QUAD $0x00014111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $321(%rcx,%rdx) + QUAD $0x00016111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $353(%rcx,%rdx) + QUAD $0x00018111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $385(%rcx,%rdx) + QUAD $0x0001a111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $417(%rcx,%rdx) + QUAD $0x0001c111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $449(%rcx,%rdx) + QUAD $0x0001e111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $481(%rcx,%rdx) + LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq $512, %rdi + LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xff67850f; WORD $0xffff // jne LBB1_85, $-153(%rip) + +LBB1_86: + WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 + LONG $0x03c2f641 // testb $3, %r10b + LONG $0x0059840f; WORD $0x0000 // je LBB1_89, $89(%rip) + WORD $0xff41; BYTE $0xc5 // incl %r13d + LONG $0x80e58141; WORD $0x0001; BYTE $0x00 // andl $384, %r13d + LONG $0x80c58341 // addl $-128, %r13d + LONG $0x07edc141 // shrl $7, %r13d + WORD $0xfe41; BYTE $0xc5 // incb %r13b + LONG $0xd5b60f41 // movzbl %r13b, %edx + WORD $0xe283; BYTE $0x03 // andl $3, %edx + LONG $0x07e2c148 // shlq $7, %rdx + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + LONG $0x61c08348 // addq $97, %rax + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff3f9056ffdc5 // vmovdqa $-3079(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_88: + LONG $0x303c8d48 // leaq (%rax,%rsi), %rdi + LONG $0x447ffec5; WORD $0xa039 // vmovdqu %ymm0, $-96(%rcx,%rdi) + LONG $0x447ffec5; WORD $0xc039 // vmovdqu %ymm0, $-64(%rcx,%rdi) + LONG $0x447ffec5; WORD $0xe039 // vmovdqu %ymm0, $-32(%rcx,%rdi) + LONG $0x047ffec5; BYTE $0x39 // vmovdqu %ymm0, (%rcx,%rdi) + LONG $0x80ee8348 // subq $-128, %rsi + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0xffd8850f; WORD $0xffff // jne LBB1_88, $-40(%rip) + +LBB1_89: + LONG $0x091c8d4a // leaq (%rcx,%r9), %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x394d; BYTE $0xe0 // cmpq %r12, %r8 + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x001e840f; WORD $0x0000 // je LBB1_122, $30(%rip) + WORD $0x8944; BYTE $0xe2 // movl %r12d, %edx + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB1_91: + WORD $0x03c6; BYTE $0x30 // movb $48, (%rbx) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xc2ff // incl %edx + WORD $0x3944; BYTE $0xda // cmpl %r11d, %edx + LONG $0xffef8c0f; WORD $0xffff // jl LBB1_91, $-17(%rip) + +LBB1_122: + WORD $0x2944; BYTE $0xd3 // subl %r10d, %ebx + +LBB1_123: + WORD $0xd889 // movl %ebx, %eax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB1_1: + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xffffe5e9; BYTE $0xff // jmp LBB1_123, $-27(%rip) + +LBB1_5: + LONG $0xfffbcebe; BYTE $0xff // movl $-1074, %esi + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0xfff441e9; BYTE $0xff // jmp LBB1_6, $-3007(%rip) + +LBB1_25: + LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + LONG $0xfff8dfe9; BYTE $0xff // jmp LBB1_26, $-1825(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_format_integer: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x20e8c148 // shrq $32, %rax + LONG $0x0016850f; WORD $0x0000 // jne LBB2_2, $22(%rip) + WORD $0x894d; BYTE $0xc3 // movq %r8, %r11 + LONG $0x2710ff81; WORD $0x0000 // cmpl $10000, %edi + LONG $0x00c3830f; WORD $0x0000 // jae LBB2_5, $195(%rip) + +LBB2_4: + WORD $0xfa89 // movl %edi, %edx + LONG $0x00011ae9; BYTE $0x00 // jmp LBB2_7, $282(%rip) + +LBB2_2: + QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0x1f00ca69; WORD $0xfa0a // imull $-100000000, %edx, %ecx + WORD $0xf901 // addl %edi, %ecx + LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xc1af0f49 // imulq %r9, %rax + LONG $0x2de8c148 // shrq $45, %rax + LONG $0x2710f869; WORD $0x0000 // imull $10000, %eax, %edi + WORD $0xf929 // subl %edi, %ecx + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xf9af0f49 // imulq %r9, %rdi + LONG $0x2defc148 // shrq $45, %rdi + LONG $0x2710ff69; WORD $0x0000 // imull $10000, %edi, %edi + WORD $0xf829 // subl %edi, %eax + WORD $0xb70f; BYTE $0xf9 // movzwl %cx, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull $5243, %edi, %r9d + LONG $0x11e9c141 // shrl $17, %r9d + LONG $0x64f96b41 // imull $100, %r9d, %edi + WORD $0xf929 // subl %edi, %ecx + LONG $0xd1b70f44 // movzwl %cx, %r10d + WORD $0xb70f; BYTE $0xf8 // movzwl %ax, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x147bff69; WORD $0x0000 // imull $5243, %edi, %edi + WORD $0xefc1; BYTE $0x11 // shrl $17, %edi + WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0xd8b70f44 // movzwl %ax, %r11d + LONG $0x500d8d48; WORD $0x00bf; BYTE $0x00 // leaq $48976(%rip), %rcx /* _Digits(%rip) */ + LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax + LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) + LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax + LONG $0x40894166; BYTE $0xfc // movw %ax, $-4(%r8) + LONG $0x04b70f42; BYTE $0x59 // movzwl (%rcx,%r11,2), %eax + LONG $0x40894166; BYTE $0xfa // movw %ax, $-6(%r8) + LONG $0xf8588d4d // leaq $-8(%r8), %r11 + LONG $0x790cb70f // movzwl (%rcx,%rdi,2), %ecx + LONG $0x48894166; BYTE $0xf8 // movw %cx, $-8(%r8) + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0x2710ff81; WORD $0x0000 // cmpl $10000, %edi + LONG $0xff3d820f; WORD $0xffff // jb LBB2_4, $-195(%rip) + +LBB2_5: + LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d + LONG $0x09158d4c; WORD $0x00bf; BYTE $0x00 // leaq $48905(%rip), %r10 /* _Digits(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB2_6: + WORD $0xfa89 // movl %edi, %edx + LONG $0xd1af0f49 // imulq %r9, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0xd8f0ca69; WORD $0xffff // imull $-10000, %edx, %ecx + WORD $0xf901 // addl %edi, %ecx + LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx + WORD $0xd929 // subl %ebx, %ecx + LONG $0x0cb70f41; BYTE $0x4a // movzwl (%r10,%rcx,2), %ecx + LONG $0x4b894166; BYTE $0xfe // movw %cx, $-2(%r11) + LONG $0x04b70f41; BYTE $0x42 // movzwl (%r10,%rax,2), %eax + LONG $0x43894166; BYTE $0xfc // movw %ax, $-4(%r11) + LONG $0xfcc38349 // addq $-4, %r11 + LONG $0xe0ffff81; WORD $0x05f5 // cmpl $99999999, %edi + WORD $0xd789 // movl %edx, %edi + LONG $0xffb8870f; WORD $0xffff // ja LBB2_6, $-72(%rip) + +LBB2_7: + WORD $0xfa83; BYTE $0x64 // cmpl $100, %edx + LONG $0x002d820f; WORD $0x0000 // jb LBB2_9, $45(%rip) + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx + WORD $0xca29 // subl %ecx, %edx + WORD $0xb70f; BYTE $0xca // movzwl %dx, %ecx + LONG $0x91158d48; WORD $0x00be; BYTE $0x00 // leaq $48785(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x4b894166; BYTE $0xfe // movw %cx, $-2(%r11) + LONG $0xfec38349 // addq $-2, %r11 + WORD $0xc289 // movl %eax, %edx + +LBB2_9: + WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx + LONG $0x0018820f; WORD $0x0000 // jb LBB2_11, $24(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x700d8d48; WORD $0x00be; BYTE $0x00 // leaq $48752(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x43894166; BYTE $0xfe // movw %ax, $-2(%r11) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB2_11: + WORD $0xc280; BYTE $0x30 // addb $48, %dl + WORD $0x1688 // movb %dl, (%rsi) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_i64toa: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x00b1880f; WORD $0x0000 // js LBB3_12, $177(%rip) + LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi + LONG $0x00b6870f; WORD $0x0000 // ja LBB3_9, $182(%rip) + WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x00148d48 // leaq (%rax,%rax), %rdx + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xf189 // movl %esi, %ecx + WORD $0xc129 // subl %eax, %ecx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi + LONG $0x0017820f; WORD $0x0000 // jb LBB3_4, $23(%rip) + LONG $0x03058d48; WORD $0x00be; BYTE $0x00 // leaq $48643(%rip), %rax /* _Digits(%rip) */ + LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x00000be9; BYTE $0x00 // jmp LBB3_5, $11(%rip) + +LBB3_4: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x0046820f; WORD $0x0000 // jb LBB3_6, $70(%rip) + +LBB3_5: + WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx + LONG $0x01ca8348 // orq $1, %rdx + LONG $0xda358d48; WORD $0x00bd; BYTE $0x00 // leaq $48602(%rip), %rsi /* _Digits(%rip) */ + LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB3_7: + LONG $0xc8158d48; WORD $0x00bd; BYTE $0x00 // leaq $48584(%rip), %rdx /* _Digits(%rip) */ + LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB3_8: + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + LONG $0x01c98348 // orq $1, %rcx + LONG $0xaf158d48; WORD $0x00bd; BYTE $0x00 // leaq $48559(%rip), %rdx /* _Digits(%rip) */ + LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx + WORD $0xc289 // movl %eax, %edx + WORD $0xc0ff // incl %eax + WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB3_6: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0xffc8830f; WORD $0xffff // jae LBB3_7, $-56(%rip) + LONG $0xffffd5e9; BYTE $0xff // jmp LBB3_8, $-43(%rip) + +LBB3_12: + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xf748; BYTE $0xde // negq %rsi + LONG $0x000044e8; BYTE $0x00 // callq _u64toa, $68(%rip) + WORD $0xc0ff // incl %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB3_9: + LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi + LONG $0x0006870f; WORD $0x0000 // ja LBB3_10, $6(%rip) + BYTE $0x5d // popq %rbp + LONG $0x00011de9; BYTE $0x00 // jmp _u32toa_medium, $285(%rip) + +LBB3_10: + QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0006870f; WORD $0x0000 // ja LBB3_11, $6(%rip) + BYTE $0x5d // popq %rbp + LONG $0x000244e9; BYTE $0x00 // jmp _u64toa_large_sse2, $580(%rip) + +LBB3_11: + BYTE $0x5d // popq %rbp + LONG $0x00038ee9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $910(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_u64toa: + LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi + LONG $0x00a8870f; WORD $0x0000 // ja LBB4_8, $168(%rip) + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x00148d48 // leaq (%rax,%rax), %rdx + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xf189 // movl %esi, %ecx + WORD $0xc129 // subl %eax, %ecx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi + LONG $0x0017820f; WORD $0x0000 // jb LBB4_3, $23(%rip) + LONG $0xfc058d48; WORD $0x00bc; BYTE $0x00 // leaq $48380(%rip), %rax /* _Digits(%rip) */ + LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x00000be9; BYTE $0x00 // jmp LBB4_4, $11(%rip) + +LBB4_3: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x0046820f; WORD $0x0000 // jb LBB4_5, $70(%rip) + +LBB4_4: + WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx + LONG $0x01ca8348 // orq $1, %rdx + LONG $0xd3358d48; WORD $0x00bc; BYTE $0x00 // leaq $48339(%rip), %rsi /* _Digits(%rip) */ + LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB4_6: + LONG $0xc1158d48; WORD $0x00bc; BYTE $0x00 // leaq $48321(%rip), %rdx /* _Digits(%rip) */ + LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB4_7: + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + LONG $0x01c98348 // orq $1, %rcx + LONG $0xa8158d48; WORD $0x00bc; BYTE $0x00 // leaq $48296(%rip), %rdx /* _Digits(%rip) */ + LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx + WORD $0xc289 // movl %eax, %edx + WORD $0xc0ff // incl %eax + WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB4_5: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0xffc8830f; WORD $0xffff // jae LBB4_6, $-56(%rip) + LONG $0xffffd5e9; BYTE $0xff // jmp LBB4_7, $-43(%rip) + +LBB4_8: + LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi + LONG $0x0005870f; WORD $0x0000 // ja LBB4_9, $5(%rip) + LONG $0x000029e9; BYTE $0x00 // jmp _u32toa_medium, $41(%rip) + +LBB4_9: + QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0005870f; WORD $0x0000 // ja LBB4_10, $5(%rip) + LONG $0x000151e9; BYTE $0x00 // jmp _u64toa_large_sse2, $337(%rip) + +LBB4_10: + LONG $0x00029ce9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $668(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +_u32toa_medium: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0xf089 // movl %esi, %eax + LONG $0xb71759b9; BYTE $0xd1 // movl $3518437209, %ecx + LONG $0xc8af0f48 // imulq %rax, %rcx + LONG $0x2de9c148 // shrq $45, %rcx + LONG $0x2710d169; WORD $0x0000 // imull $10000, %ecx, %edx + WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d + WORD $0x2941; BYTE $0xd0 // subl %edx, %r8d + LONG $0x83d06948; WORD $0x1bde; BYTE $0x43 // imulq $1125899907, %rax, %rdx + LONG $0x31eac148 // shrq $49, %rdx + WORD $0xe283; BYTE $0xfe // andl $-2, %edx + LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xc129 // subl %eax, %ecx + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0x9680fe81; WORD $0x0098 // cmpl $10000000, %esi + LONG $0x0017820f; WORD $0x0000 // jb LBB5_2, $23(%rip) + LONG $0xfd058d48; WORD $0x00bb; BYTE $0x00 // leaq $48125(%rip), %rax /* _Digits(%rip) */ + LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x00000ee9; BYTE $0x00 // jmp LBB5_3, $14(%rip) + +LBB5_2: + WORD $0xc031 // xorl %eax, %eax + LONG $0x4240fe81; WORD $0x000f // cmpl $1000000, %esi + LONG $0x0074820f; WORD $0x0000 // jb LBB5_4, $116(%rip) + +LBB5_3: + WORD $0xd289 // movl %edx, %edx + LONG $0x01ca8348 // orq $1, %rdx + LONG $0xd2358d48; WORD $0x00bb; BYTE $0x00 // leaq $48082(%rip), %rsi /* _Digits(%rip) */ + LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB5_5: + LONG $0xc0158d48; WORD $0x00bb; BYTE $0x00 // leaq $48064(%rip), %rdx /* _Digits(%rip) */ + LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB5_6: + LONG $0xd0b70f41 // movzwl %r8w, %edx + WORD $0xeac1; BYTE $0x02 // shrl $2, %edx + LONG $0x147bd269; WORD $0x0000 // imull $5243, %edx, %edx + WORD $0xeac1; BYTE $0x11 // shrl $17, %edx + WORD $0xf26b; BYTE $0x64 // imull $100, %edx, %esi + WORD $0x2941; BYTE $0xf0 // subl %esi, %r8d + LONG $0xc0b70f45 // movzwl %r8w, %r8d + WORD $0xc989 // movl %ecx, %ecx + LONG $0x01c98348 // orq $1, %rcx + LONG $0x8e0d8d4c; WORD $0x00bb; BYTE $0x00 // leaq $48014(%rip), %r9 /* _Digits(%rip) */ + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xc689 // movl %eax, %esi + WORD $0x0c88; BYTE $0x37 // movb %cl, (%rdi,%rsi) + LONG $0x0cb70f41; BYTE $0x51 // movzwl (%r9,%rdx,2), %ecx + LONG $0x374c8966; BYTE $0x01 // movw %cx, $1(%rdi,%rsi) + LONG $0x0cb70f43; BYTE $0x41 // movzwl (%r9,%r8,2), %ecx + LONG $0x374c8966; BYTE $0x03 // movw %cx, $3(%rdi,%rsi) + WORD $0xc083; BYTE $0x05 // addl $5, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB5_4: + WORD $0xc031 // xorl %eax, %eax + LONG $0x86a0fe81; WORD $0x0001 // cmpl $100000, %esi + LONG $0xff96830f; WORD $0xffff // jae LBB5_5, $-106(%rip) + LONG $0xffffa3e9; BYTE $0xff // jmp LBB5_6, $-93(%rip) + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +LCPI6_0: + QUAD $0x00000000d1b71759 // .quad 3518437209 + QUAD $0x00000000d1b71759 // .quad 3518437209 + +LCPI6_3: + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + +LCPI6_4: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 3, 0x00 +LCPI6_1: + QUAD $0x80003334147b20c5 // .quad -9223315738079846203 + +LCPI6_2: + QUAD $0x8000200008000080 // .quad -9223336852348469120 + + // .p2align 4, 0x90 +_u64toa_large_sse2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax + WORD $0xc629 // subl %eax, %esi + LONG $0xc26ef9c5 // vmovd %edx, %xmm0 + QUAD $0xffffff940d6ff9c5 // vmovdqa $-108(%rip), %xmm1 /* LCPI6_0(%rip) */ + LONG $0xd1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm2 + LONG $0xd273e9c5; BYTE $0x2d // vpsrlq $45, %xmm2, %xmm2 + LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax + LONG $0x6ef9e1c4; BYTE $0xd8 // vmovq %rax, %xmm3 + LONG $0xe3f4e9c5 // vpmuludq %xmm3, %xmm2, %xmm4 + LONG $0xc4faf9c5 // vpsubd %xmm4, %xmm0, %xmm0 + LONG $0xc061e9c5 // vpunpcklwd %xmm0, %xmm2, %xmm0 + LONG $0xf073f9c5; BYTE $0x02 // vpsllq $2, %xmm0, %xmm0 + LONG $0xc070fbc5; BYTE $0x50 // vpshuflw $80, %xmm0, %xmm0 + LONG $0xc070f9c5; BYTE $0x50 // vpshufd $80, %xmm0, %xmm0 + QUAD $0xffff8d155979e2c4; BYTE $0xff // vpbroadcastq $-115(%rip), %xmm2 /* LCPI6_1(%rip) */ + LONG $0xc2e4f9c5 // vpmulhuw %xmm2, %xmm0, %xmm0 + QUAD $0xffff88255979e2c4; BYTE $0xff // vpbroadcastq $-120(%rip), %xmm4 /* LCPI6_2(%rip) */ + LONG $0xc4e4f9c5 // vpmulhuw %xmm4, %xmm0, %xmm0 + QUAD $0xffffff542d6ff9c5 // vmovdqa $-172(%rip), %xmm5 /* LCPI6_3(%rip) */ + LONG $0xf5d5f9c5 // vpmullw %xmm5, %xmm0, %xmm6 + LONG $0xf673c9c5; BYTE $0x10 // vpsllq $16, %xmm6, %xmm6 + LONG $0xc6f9f9c5 // vpsubw %xmm6, %xmm0, %xmm0 + LONG $0xf66ef9c5 // vmovd %esi, %xmm6 + LONG $0xc9f4c9c5 // vpmuludq %xmm1, %xmm6, %xmm1 + LONG $0xd173f1c5; BYTE $0x2d // vpsrlq $45, %xmm1, %xmm1 + LONG $0xdbf4f1c5 // vpmuludq %xmm3, %xmm1, %xmm3 + LONG $0xdbfac9c5 // vpsubd %xmm3, %xmm6, %xmm3 + LONG $0xcb61f1c5 // vpunpcklwd %xmm3, %xmm1, %xmm1 + LONG $0xf173f1c5; BYTE $0x02 // vpsllq $2, %xmm1, %xmm1 + LONG $0xc970fbc5; BYTE $0x50 // vpshuflw $80, %xmm1, %xmm1 + LONG $0xc970f9c5; BYTE $0x50 // vpshufd $80, %xmm1, %xmm1 + LONG $0xcae4f1c5 // vpmulhuw %xmm2, %xmm1, %xmm1 + LONG $0xcce4f1c5 // vpmulhuw %xmm4, %xmm1, %xmm1 + LONG $0xd5d5f1c5 // vpmullw %xmm5, %xmm1, %xmm2 + LONG $0xf273e9c5; BYTE $0x10 // vpsllq $16, %xmm2, %xmm2 + LONG $0xcaf9f1c5 // vpsubw %xmm2, %xmm1, %xmm1 + LONG $0xc167f9c5 // vpackuswb %xmm1, %xmm0, %xmm0 + QUAD $0xffffff0e0dfcf9c5 // vpaddb $-242(%rip), %xmm0, %xmm1 /* LCPI6_4(%rip) */ + LONG $0xd2efe9c5 // vpxor %xmm2, %xmm2, %xmm2 + LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 + LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax + WORD $0xd0f7 // notl %eax + LONG $0x0080000d; BYTE $0x00 // orl $32768, %eax + WORD $0xbc0f; BYTE $0xc8 // bsfl %eax, %ecx + LONG $0x000010b8; BYTE $0x00 // movl $16, %eax + WORD $0xc829 // subl %ecx, %eax + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x76158d48; WORD $0x00e1; BYTE $0x00 // leaq $57718(%rip), %rdx /* _VecShiftShuffles(%rip) */ + LONG $0x0071e2c4; WORD $0x1104 // vpshufb (%rcx,%rdx), %xmm1, %xmm0 + LONG $0x077ffac5 // vmovdqu %xmm0, (%rdi) + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI7_0: + QUAD $0x00000000d1b71759 // .quad 3518437209 + QUAD $0x00000000d1b71759 // .quad 3518437209 + +LCPI7_3: + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + +LCPI7_4: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 3, 0x00 +LCPI7_1: + QUAD $0x80003334147b20c5 // .quad -9223315738079846203 + +LCPI7_2: + QUAD $0x8000200008000080 // .quad -9223336852348469120 + + // .p2align 4, 0x90 +_u64toa_xlarge_sse2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + QUAD $0x652fb1137857b948; WORD $0x39a5 // movabsq $4153837486827862103, %rcx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x33eac148 // shrq $51, %rdx + QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax + LONG $0xc2af0f48 // imulq %rdx, %rax + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + WORD $0xfa83; BYTE $0x09 // cmpl $9, %edx + LONG $0x000f870f; WORD $0x0000 // ja LBB7_2, $15(%rip) + WORD $0xc280; BYTE $0x30 // addb $48, %dl + WORD $0x1788 // movb %dl, (%rdi) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + LONG $0x0000a7e9; BYTE $0x00 // jmp LBB7_7, $167(%rip) + +LBB7_2: + WORD $0xfa83; BYTE $0x63 // cmpl $99, %edx + LONG $0x001a870f; WORD $0x0000 // ja LBB7_4, $26(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x6d0d8d48; WORD $0x00b9; BYTE $0x00 // leaq $47469(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx + LONG $0x000084e9; BYTE $0x00 // jmp LBB7_7, $132(%rip) + +LBB7_4: + WORD $0xd089 // movl %edx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x03e7fa81; WORD $0x0000 // cmpl $999, %edx + LONG $0x0037870f; WORD $0x0000 // ja LBB7_6, $55(%rip) + WORD $0xc083; BYTE $0x30 // addl $48, %eax + WORD $0x0788 // movb %al, (%rdi) + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x02 // shrl $2, %ecx + LONG $0x147bc969; WORD $0x0000 // imull $5243, %ecx, %ecx + WORD $0xe9c1; BYTE $0x11 // shrl $17, %ecx + WORD $0xc96b; BYTE $0x64 // imull $100, %ecx, %ecx + WORD $0xc829 // subl %ecx, %eax + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0x1d0d8d48; WORD $0x00b9; BYTE $0x00 // leaq $47389(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x01478966 // movw %ax, $1(%rdi) + LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx + LONG $0x000033e9; BYTE $0x00 // jmp LBB7_7, $51(%rip) + +LBB7_6: + WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx + WORD $0xca29 // subl %ecx, %edx + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0xfc0d8d48; WORD $0x00b8; BYTE $0x00 // leaq $47356(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + LONG $0x4114b60f // movzbl (%rcx,%rax,2), %edx + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax + WORD $0x5788; BYTE $0x02 // movb %dl, $2(%rdi) + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0x0844b60f; BYTE $0x01 // movzbl $1(%rax,%rcx), %eax + WORD $0x4788; BYTE $0x03 // movb %al, $3(%rdi) + LONG $0x000004b9; BYTE $0x00 // movl $4, %ecx + +LBB7_7: + QUAD $0x77118461cefdba48; WORD $0xabcc // movabsq $-6067343680855748867, %rdx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe2 // mulq %rdx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0xc26ef9c5 // vmovd %edx, %xmm0 + QUAD $0xfffffeb80d6ff9c5 // vmovdqa $-328(%rip), %xmm1 /* LCPI7_0(%rip) */ + LONG $0xd1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm2 + LONG $0xd273e9c5; BYTE $0x2d // vpsrlq $45, %xmm2, %xmm2 + LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax + LONG $0x6ef9e1c4; BYTE $0xd8 // vmovq %rax, %xmm3 + LONG $0xe3f4e9c5 // vpmuludq %xmm3, %xmm2, %xmm4 + LONG $0xc4faf9c5 // vpsubd %xmm4, %xmm0, %xmm0 + LONG $0xc061e9c5 // vpunpcklwd %xmm0, %xmm2, %xmm0 + LONG $0xf073f9c5; BYTE $0x02 // vpsllq $2, %xmm0, %xmm0 + LONG $0xc070fbc5; BYTE $0x50 // vpshuflw $80, %xmm0, %xmm0 + QUAD $0xfffeb6155979e2c4; BYTE $0xff // vpbroadcastq $-330(%rip), %xmm2 /* LCPI7_1(%rip) */ + LONG $0xc070f9c5; BYTE $0x50 // vpshufd $80, %xmm0, %xmm0 + LONG $0xc2e4f9c5 // vpmulhuw %xmm2, %xmm0, %xmm0 + QUAD $0xfffeac255979e2c4; BYTE $0xff // vpbroadcastq $-340(%rip), %xmm4 /* LCPI7_2(%rip) */ + LONG $0xc4e4f9c5 // vpmulhuw %xmm4, %xmm0, %xmm0 + QUAD $0xfffffe782d6ff9c5 // vmovdqa $-392(%rip), %xmm5 /* LCPI7_3(%rip) */ + LONG $0xf5d5f9c5 // vpmullw %xmm5, %xmm0, %xmm6 + LONG $0xf673c9c5; BYTE $0x10 // vpsllq $16, %xmm6, %xmm6 + LONG $0xc6f9f9c5 // vpsubw %xmm6, %xmm0, %xmm0 + LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax + WORD $0xc629 // subl %eax, %esi + LONG $0xf66ef9c5 // vmovd %esi, %xmm6 + LONG $0xc9f4c9c5 // vpmuludq %xmm1, %xmm6, %xmm1 + LONG $0xd173f1c5; BYTE $0x2d // vpsrlq $45, %xmm1, %xmm1 + LONG $0xdbf4f1c5 // vpmuludq %xmm3, %xmm1, %xmm3 + LONG $0xdbfac9c5 // vpsubd %xmm3, %xmm6, %xmm3 + LONG $0xcb61f1c5 // vpunpcklwd %xmm3, %xmm1, %xmm1 + LONG $0xf173f1c5; BYTE $0x02 // vpsllq $2, %xmm1, %xmm1 + LONG $0xc970fbc5; BYTE $0x50 // vpshuflw $80, %xmm1, %xmm1 + LONG $0xc970f9c5; BYTE $0x50 // vpshufd $80, %xmm1, %xmm1 + LONG $0xcae4f1c5 // vpmulhuw %xmm2, %xmm1, %xmm1 + LONG $0xcce4f1c5 // vpmulhuw %xmm4, %xmm1, %xmm1 + LONG $0xd5d5f1c5 // vpmullw %xmm5, %xmm1, %xmm2 + LONG $0xf273e9c5; BYTE $0x10 // vpsllq $16, %xmm2, %xmm2 + LONG $0xcaf9f1c5 // vpsubw %xmm2, %xmm1, %xmm1 + LONG $0xc167f9c5 // vpackuswb %xmm1, %xmm0, %xmm0 + QUAD $0xfffffe2a05fcf9c5 // vpaddb $-470(%rip), %xmm0, %xmm0 /* LCPI7_4(%rip) */ + WORD $0xc889 // movl %ecx, %eax + LONG $0x047ffac5; BYTE $0x07 // vmovdqu %xmm0, (%rdi,%rax) + WORD $0xc983; BYTE $0x10 // orl $16, %ecx + WORD $0xc889 // movl %ecx, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 5, 0x00 + +LCPI8_0: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI8_1: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI8_2: + QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' + QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' + + // .p2align 4, 0x00 +LCPI8_3: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI8_4: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI8_5: + QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' + + // .p2align 4, 0x90 +_quote: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x18ec8348 // subq $24, %rsp + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b4c; BYTE $0x11 // movq (%rcx), %r10 + LONG $0x01c0f641 // testb $1, %r8b + LONG $0x1b058d48; WORD $0x00df; BYTE $0x00 // leaq $57115(%rip), %rax /* __SingleQuoteTab(%rip) */ + LONG $0x14058d4c; WORD $0x00ef; BYTE $0x00 // leaq $61204(%rip), %r8 /* __DoubleQuoteTab(%rip) */ + LONG $0xc0440f4c // cmoveq %rax, %r8 + QUAD $0x00000000f5048d48 // leaq (,%rsi,8), %rax + WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 + LONG $0x07128d0f; WORD $0x0000 // jge LBB8_93, $1810(%rip) + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + WORD $0x8949; BYTE $0xfb // movq %rdi, %r11 + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x09ef840f; WORD $0x0000 // je LBB8_122, $2543(%rip) + QUAD $0xffffff181d6ffdc5 // vmovdqa $-232(%rip), %ymm3 /* LCPI8_0(%rip) */ + QUAD $0xffffff30256ffdc5 // vmovdqa $-208(%rip), %ymm4 /* LCPI8_1(%rip) */ + QUAD $0xffffff482d6ffdc5 // vmovdqa $-184(%rip), %ymm5 /* LCPI8_2(%rip) */ + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + LONG $0xc0558948 // movq %rdx, $-64(%rbp) + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + +LBB8_3: + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + LONG $0x20fe8349 // cmpq $32, %r14 + WORD $0x9d0f; BYTE $0xc1 // setge %cl + LONG $0x20fa8349 // cmpq $32, %r10 + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x894d; BYTE $0xcc // movq %r9, %r12 + WORD $0x894d; BYTE $0xf3 // movq %r14, %r11 + LONG $0x007e8c0f; WORD $0x0000 // jl LBB8_10, $126(%rip) + LONG $0x20fe8349 // cmpq $32, %r14 + LONG $0x00748c0f; WORD $0x0000 // jl LBB8_10, $116(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB8_6: + LONG $0x6f7ea1c4; WORD $0x2004 // vmovdqu (%rax,%r12), %ymm0 + LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 + LONG $0xd474fdc5 // vpcmpeqb %ymm4, %ymm0, %ymm2 + LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 + LONG $0x7f7e81c4; WORD $0x2104 // vmovdqu %ymm0, (%r9,%r12) + LONG $0xd5dafdc5 // vpminub %ymm5, %ymm0, %ymm2 + LONG $0xc274fdc5 // vpcmpeqb %ymm2, %ymm0, %ymm0 + LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 + LONG $0xc8d7fdc5 // vpmovmskb %ymm0, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x01d8850f; WORD $0x0000 // jne LBB8_20, $472(%rip) + LONG $0xe05e8d4c // leaq $-32(%rsi), %r11 + LONG $0xe05a8d48 // leaq $-32(%rdx), %rbx + LONG $0x20c48349 // addq $32, %r12 + LONG $0x40fe8348 // cmpq $64, %rsi + WORD $0x9d0f; BYTE $0xc1 // setge %cl + LONG $0x00108c0f; WORD $0x0000 // jl LBB8_9, $16(%rip) + WORD $0x894c; BYTE $0xde // movq %r11, %rsi + LONG $0x3ffa8348 // cmpq $63, %rdx + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx + LONG $0xffa78f0f; WORD $0xffff // jg LBB8_6, $-89(%rip) + +LBB8_9: + LONG $0x202c8d4e // leaq (%rax,%r12), %r13 + WORD $0x014d; BYTE $0xcc // addq %r9, %r12 + +LBB8_10: + WORD $0xc984 // testb %cl, %cl + LONG $0x007b840f; WORD $0x0000 // je LBB8_14, $123(%rip) + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0x6f7ec1c4; WORD $0x0045 // vmovdqu (%r13), %ymm0 + LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 + LONG $0xd474fdc5 // vpcmpeqb %ymm4, %ymm0, %ymm2 + LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 + LONG $0xd5dafdc5 // vpminub %ymm5, %ymm0, %ymm2 + LONG $0xc274fdc5 // vpcmpeqb %ymm2, %ymm0, %ymm0 + LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 + LONG $0xc8d7fdc5 // vpmovmskb %ymm0, %ecx + QUAD $0x000100000000ba48; WORD $0x0000 // movabsq $4294967296, %rdx + WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx + LONG $0xf1bc0f4c // bsfq %rcx, %r14 + LONG $0x00558b49 // movq (%r13), %rdx + LONG $0x084d8b49 // movq $8(%r13), %rcx + WORD $0x3949; BYTE $0xde // cmpq %rbx, %r14 + LONG $0x01688e0f; WORD $0x0000 // jle LBB8_21, $360(%rip) + LONG $0x10fb8348 // cmpq $16, %rbx + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + LONG $0x01a7820f; WORD $0x0000 // jb LBB8_24, $423(%rip) + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x244c8949; BYTE $0x08 // movq %rcx, $8(%r12) + LONG $0x104d8d49 // leaq $16(%r13), %rcx + LONG $0x10c48349 // addq $16, %r12 + LONG $0xf0538d48 // leaq $-16(%rbx), %rdx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + LONG $0x08fa8348 // cmpq $8, %rdx + LONG $0x0198830f; WORD $0x0000 // jae LBB8_25, $408(%rip) + LONG $0x0001a6e9; BYTE $0x00 // jmp LBB8_26, $422(%rip) + +LBB8_14: + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x10fb8349 // cmpq $16, %r11 + WORD $0x9d0f; BYTE $0xc2 // setge %dl + LONG $0xc87d894c // movq %r15, $-56(%rbp) + LONG $0xd075894c // movq %r14, $-48(%rbp) + LONG $0x02018c0f; WORD $0x0000 // jl LBB8_31, $513(%rip) + LONG $0x10fb8348 // cmpq $16, %rbx + QUAD $0xfffffe19356ff9c5 // vmovdqa $-487(%rip), %xmm6 /* LCPI8_3(%rip) */ + QUAD $0xfffffe213d6ff9c5 // vmovdqa $-479(%rip), %xmm7 /* LCPI8_4(%rip) */ + QUAD $0xfffffe29056f79c5 // vmovdqa $-471(%rip), %xmm8 /* LCPI8_5(%rip) */ + LONG $0x02228c0f; WORD $0x0000 // jl LBB8_36, $546(%rip) + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x294c; BYTE $0xe9 // subq %r13, %rcx + QUAD $0xfffffd951d6ffdc5 // vmovdqa $-619(%rip), %ymm3 /* LCPI8_0(%rip) */ + QUAD $0xfffffdad256ffdc5 // vmovdqa $-595(%rip), %ymm4 /* LCPI8_1(%rip) */ + QUAD $0xfffffdc52d6ffdc5 // vmovdqa $-571(%rip), %ymm5 /* LCPI8_2(%rip) */ + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB8_17: + LONG $0x6f7ac1c4; WORD $0x0045 // vmovdqu (%r13), %xmm0 + LONG $0xce74f9c5 // vpcmpeqb %xmm6, %xmm0, %xmm1 + LONG $0xd774f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm2 + LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 + LONG $0x7f7ac1c4; WORD $0x2404 // vmovdqu %xmm0, (%r12) + LONG $0xd0dab9c5 // vpminub %xmm0, %xmm8, %xmm2 + LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 + LONG $0xc0ebf1c5 // vpor %xmm0, %xmm1, %xmm0 + LONG $0xd0d7f9c5 // vpmovmskb %xmm0, %edx + WORD $0xd285 // testl %edx, %edx + LONG $0x00d8850f; WORD $0x0000 // jne LBB8_23, $216(%rip) + LONG $0x10c58349 // addq $16, %r13 + LONG $0x10c48349 // addq $16, %r12 + LONG $0xf07b8d4d // leaq $-16(%r11), %r15 + LONG $0xf0738d4c // leaq $-16(%rbx), %r14 + LONG $0x20fb8349 // cmpq $32, %r11 + WORD $0x9d0f; BYTE $0xc2 // setge %dl + LONG $0x00148c0f; WORD $0x0000 // jl LBB8_32, $20(%rip) + LONG $0xf0c18348 // addq $-16, %rcx + WORD $0x894d; BYTE $0xfb // movq %r15, %r11 + LONG $0x1ffb8348 // cmpq $31, %rbx + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + LONG $0xff9f8f0f; WORD $0xffff // jg LBB8_17, $-97(%rip) + +LBB8_32: + WORD $0xd284 // testb %dl, %dl + LONG $0x01bc840f; WORD $0x0000 // je LBB8_37, $444(%rip) + +LBB8_33: + LONG $0x6f7ac1c4; WORD $0x0045 // vmovdqu (%r13), %xmm0 + LONG $0xce74f9c5 // vpcmpeqb %xmm6, %xmm0, %xmm1 + LONG $0xd774f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm2 + LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 + LONG $0xd0dab9c5 // vpminub %xmm0, %xmm8, %xmm2 + LONG $0xd274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm2 + LONG $0xcaebf1c5 // vpor %xmm2, %xmm1, %xmm1 + LONG $0xc9d7f9c5 // vpmovmskb %xmm1, %ecx + LONG $0x0000c981; WORD $0x0001 // orl $65536, %ecx + WORD $0xbc0f; BYTE $0xd9 // bsfl %ecx, %ebx + LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx + WORD $0x3949; BYTE $0xde // cmpq %rbx, %r14 + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + LONG $0x029e8d0f; WORD $0x0000 // jge LBB8_57, $670(%rip) + LONG $0x08fe8349 // cmpq $8, %r14 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + LONG $0x02cd820f; WORD $0x0000 // jb LBB8_62, $717(%rip) + LONG $0x240c8949 // movq %rcx, (%r12) + LONG $0x084d8d49 // leaq $8(%r13), %rcx + LONG $0x08c48349 // addq $8, %r12 + LONG $0xf8568d49 // leaq $-8(%r14), %rdx + LONG $0x0002bee9; BYTE $0x00 // jmp LBB8_63, $702(%rip) + +LBB8_20: + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + LONG $0xe9bc0f44 // bsfl %ecx, %r13d + WORD $0x014d; BYTE $0xe5 // addq %r12, %r13 + LONG $0x000379e9; BYTE $0x00 // jmp LBB8_75, $889(%rip) + +LBB8_21: + LONG $0x10fe8341 // cmpl $16, %r14d + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + LONG $0x01cc820f; WORD $0x0000 // jb LBB8_46, $460(%rip) + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x244c8949; BYTE $0x08 // movq %rcx, $8(%r12) + LONG $0x105d8d49 // leaq $16(%r13), %rbx + LONG $0x10c48349 // addq $16, %r12 + LONG $0xf04e8d49 // leaq $-16(%r14), %rcx + LONG $0x08f98348 // cmpq $8, %rcx + LONG $0x01bd830f; WORD $0x0000 // jae LBB8_47, $445(%rip) + LONG $0x0001cbe9; BYTE $0x00 // jmp LBB8_48, $459(%rip) + +LBB8_23: + LONG $0xd2bc0f66 // bsfw %dx, %dx + LONG $0xeab70f44 // movzwl %dx, %r13d + WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + LONG $0xd0758b4c // movq $-48(%rbp), %r14 + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + LONG $0x00032de9; BYTE $0x00 // jmp LBB8_75, $813(%rip) + +LBB8_24: + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + LONG $0x08fa8348 // cmpq $8, %rdx + LONG $0x0013820f; WORD $0x0000 // jb LBB8_26, $19(%rip) + +LBB8_25: + WORD $0x8b48; BYTE $0x31 // movq (%rcx), %rsi + LONG $0x24348949 // movq %rsi, (%r12) + LONG $0x08c18348 // addq $8, %rcx + LONG $0x08c48349 // addq $8, %r12 + LONG $0xf8c28348 // addq $-8, %rdx + +LBB8_26: + LONG $0x04fa8348 // cmpq $4, %rdx + LONG $0x003d8c0f; WORD $0x0000 // jl LBB8_27, $61(%rip) + WORD $0x318b // movl (%rcx), %esi + LONG $0x24348941 // movl %esi, (%r12) + LONG $0x04c18348 // addq $4, %rcx + LONG $0x04c48349 // addq $4, %r12 + LONG $0xfcc28348 // addq $-4, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x002b830f; WORD $0x0000 // jae LBB8_54, $43(%rip) + +LBB8_28: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0007840f; WORD $0x0000 // je LBB8_30, $7(%rip) + +LBB8_29: + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + LONG $0x240c8841 // movb %cl, (%r12) + +LBB8_30: + WORD $0x014c; BYTE $0xeb // addq %r13, %rbx + WORD $0xf748; BYTE $0xd3 // notq %rbx + WORD $0x014c; BYTE $0xdb // addq %r11, %rbx + WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 + LONG $0x0002c0e9; BYTE $0x00 // jmp LBB8_75, $704(%rip) + +LBB8_27: + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0xffd5820f; WORD $0xffff // jb LBB8_28, $-43(%rip) + +LBB8_54: + WORD $0xb70f; BYTE $0x31 // movzwl (%rcx), %esi + LONG $0x34894166; BYTE $0x24 // movw %si, (%r12) + LONG $0x02c18348 // addq $2, %rcx + LONG $0x02c48349 // addq $2, %r12 + LONG $0xfec28348 // addq $-2, %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffc1850f; WORD $0xffff // jne LBB8_29, $-63(%rip) + LONG $0xffffc3e9; BYTE $0xff // jmp LBB8_30, $-61(%rip) + +LBB8_31: + WORD $0x8949; BYTE $0xde // movq %rbx, %r14 + WORD $0x894d; BYTE $0xdf // movq %r11, %r15 + QUAD $0xfffffbb61d6ffdc5 // vmovdqa $-1098(%rip), %ymm3 /* LCPI8_0(%rip) */ + QUAD $0xfffffbce256ffdc5 // vmovdqa $-1074(%rip), %ymm4 /* LCPI8_1(%rip) */ + QUAD $0xfffffbe62d6ffdc5 // vmovdqa $-1050(%rip), %ymm5 /* LCPI8_2(%rip) */ + QUAD $0xfffffbfe356ff9c5 // vmovdqa $-1026(%rip), %xmm6 /* LCPI8_3(%rip) */ + QUAD $0xfffffc063d6ff9c5 // vmovdqa $-1018(%rip), %xmm7 /* LCPI8_4(%rip) */ + QUAD $0xfffffc0e056f79c5 // vmovdqa $-1010(%rip), %xmm8 /* LCPI8_5(%rip) */ + WORD $0xd284 // testb %dl, %dl + LONG $0x002b840f; WORD $0x0000 // je LBB8_37, $43(%rip) + LONG $0xfffe6ae9; BYTE $0xff // jmp LBB8_33, $-406(%rip) + +LBB8_36: + WORD $0x8949; BYTE $0xde // movq %rbx, %r14 + WORD $0x894d; BYTE $0xdf // movq %r11, %r15 + QUAD $0xfffffb731d6ffdc5 // vmovdqa $-1165(%rip), %ymm3 /* LCPI8_0(%rip) */ + QUAD $0xfffffb8b256ffdc5 // vmovdqa $-1141(%rip), %ymm4 /* LCPI8_1(%rip) */ + QUAD $0xfffffba32d6ffdc5 // vmovdqa $-1117(%rip), %ymm5 /* LCPI8_2(%rip) */ + WORD $0xd284 // testb %dl, %dl + LONG $0xfe44850f; WORD $0xffff // jne LBB8_33, $-444(%rip) + +LBB8_37: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + LONG $0x005d8e0f; WORD $0x0000 // jle LBB8_44, $93(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x00548e0f; WORD $0x0000 // jle LBB8_44, $84(%rip) + WORD $0xd231 // xorl %edx, %edx + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x9090 // .p2align 4, 0x90 + +LBB8_40: + LONG $0x5cb60f41; WORD $0x0015 // movzbl (%r13,%rdx), %ebx + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0x04e6c148 // shlq $4, %rsi + LONG $0xfc058d48; WORD $0x00da; BYTE $0x00 // leaq $56060(%rip), %rax /* __SingleQuoteTab(%rip) */ + LONG $0x063c8348; BYTE $0x00 // cmpq $0, (%rsi,%rax) + LONG $0x0112850f; WORD $0x0000 // jne LBB8_61, $274(%rip) + LONG $0x0f048d49 // leaq (%r15,%rcx), %rax + LONG $0x141c8841 // movb %bl, (%r12,%rdx) + LONG $0xff718d48 // leaq $-1(%rcx), %rsi + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x00138c0f; WORD $0x0000 // jl LBB8_43, $19(%rip) + WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0x01f98348 // cmpq $1, %rcx + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + LONG $0xffb88f0f; WORD $0xffff // jg LBB8_40, $-72(%rip) + +LBB8_43: + WORD $0x2949; BYTE $0xf5 // subq %rsi, %r13 + WORD $0x0149; BYTE $0xf7 // addq %rsi, %r15 + +LBB8_44: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xd0758b4c // movq $-48(%rbp), %r14 + QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 + LONG $0x00c0840f; WORD $0x0000 // je LBB8_59, $192(%rip) + WORD $0xf749; BYTE $0xd5 // notq %r13 + WORD $0x014d; BYTE $0xdd // addq %r11, %r13 + LONG $0x0000b8e9; BYTE $0x00 // jmp LBB8_60, $184(%rip) + +LBB8_46: + WORD $0x894c; BYTE $0xeb // movq %r13, %rbx + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + LONG $0x08f98348 // cmpq $8, %rcx + LONG $0x0013820f; WORD $0x0000 // jb LBB8_48, $19(%rip) + +LBB8_47: + WORD $0x8b48; BYTE $0x13 // movq (%rbx), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x08c38348 // addq $8, %rbx + LONG $0x08c48349 // addq $8, %r12 + LONG $0xf8c18348 // addq $-8, %rcx + +LBB8_48: + LONG $0x04f98348 // cmpq $4, %rcx + LONG $0x003a820f; WORD $0x0000 // jb LBB8_49, $58(%rip) + WORD $0x138b // movl (%rbx), %edx + LONG $0x24148941 // movl %edx, (%r12) + LONG $0x04c38348 // addq $4, %rbx + LONG $0x04c48349 // addq $4, %r12 + LONG $0xfcc18348 // addq $-4, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x0028830f; WORD $0x0000 // jae LBB8_56, $40(%rip) + +LBB8_50: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0007840f; WORD $0x0000 // je LBB8_52, $7(%rip) + +LBB8_51: + WORD $0xb60f; BYTE $0x0b // movzbl (%rbx), %ecx + LONG $0x240c8841 // movb %cl, (%r12) + +LBB8_52: + WORD $0x294d; BYTE $0xdd // subq %r11, %r13 + WORD $0x014d; BYTE $0xf5 // addq %r14, %r13 + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + LONG $0x000139e9; BYTE $0x00 // jmp LBB8_75, $313(%rip) + +LBB8_49: + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0xffd8820f; WORD $0xffff // jb LBB8_50, $-40(%rip) + +LBB8_56: + WORD $0xb70f; BYTE $0x13 // movzwl (%rbx), %edx + LONG $0x14894166; BYTE $0x24 // movw %dx, (%r12) + LONG $0x02c38348 // addq $2, %rbx + LONG $0x02c48349 // addq $2, %r12 + LONG $0xfec18348 // addq $-2, %rcx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0xffc4850f; WORD $0xffff // jne LBB8_51, $-60(%rip) + LONG $0xffffc6e9; BYTE $0xff // jmp LBB8_52, $-58(%rip) + +LBB8_57: + WORD $0xfb83; BYTE $0x08 // cmpl $8, %ebx + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + LONG $0x00ad820f; WORD $0x0000 // jb LBB8_69, $173(%rip) + LONG $0x240c8949 // movq %rcx, (%r12) + LONG $0x08558d49 // leaq $8(%r13), %rdx + LONG $0x08c48349 // addq $8, %r12 + LONG $0xf84b8d48 // leaq $-8(%rbx), %rcx + LONG $0x00009ee9; BYTE $0x00 // jmp LBB8_70, $158(%rip) + +LBB8_59: + WORD $0x294d; BYTE $0xdd // subq %r11, %r13 + +LBB8_60: + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + LONG $0x0000e9e9; BYTE $0x00 // jmp LBB8_76, $233(%rip) + +LBB8_61: + WORD $0x294d; BYTE $0xdd // subq %r11, %r13 + WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + LONG $0x000048e9; BYTE $0x00 // jmp LBB8_68, $72(%rip) + +LBB8_62: + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx + +LBB8_63: + LONG $0x04fa8348 // cmpq $4, %rdx + LONG $0x00418c0f; WORD $0x0000 // jl LBB8_64, $65(%rip) + WORD $0x318b // movl (%rcx), %esi + LONG $0x24348941 // movl %esi, (%r12) + LONG $0x04c18348 // addq $4, %rcx + LONG $0x04c48349 // addq $4, %r12 + LONG $0xfcc28348 // addq $-4, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x002f830f; WORD $0x0000 // jae LBB8_90, $47(%rip) + +LBB8_65: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0007840f; WORD $0x0000 // je LBB8_67, $7(%rip) + +LBB8_66: + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + LONG $0x240c8841 // movb %cl, (%r12) + +LBB8_67: + WORD $0x014d; BYTE $0xee // addq %r13, %r14 + WORD $0xf749; BYTE $0xd6 // notq %r14 + WORD $0x014d; BYTE $0xde // addq %r11, %r14 + WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 + +LBB8_68: + LONG $0xd0758b4c // movq $-48(%rbp), %r14 + LONG $0x00007fe9; BYTE $0x00 // jmp LBB8_75, $127(%rip) + +LBB8_64: + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0xffd1820f; WORD $0xffff // jb LBB8_65, $-47(%rip) + +LBB8_90: + WORD $0xb70f; BYTE $0x31 // movzwl (%rcx), %esi + LONG $0x34894166; BYTE $0x24 // movw %si, (%r12) + LONG $0x02c18348 // addq $2, %rcx + LONG $0x02c48349 // addq $2, %r12 + LONG $0xfec28348 // addq $-2, %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffbd850f; WORD $0xffff // jne LBB8_66, $-67(%rip) + LONG $0xffffbfe9; BYTE $0xff // jmp LBB8_67, $-65(%rip) + +LBB8_69: + WORD $0x894c; BYTE $0xea // movq %r13, %rdx + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx + +LBB8_70: + LONG $0xd0758b4c // movq $-48(%rbp), %r14 + LONG $0x04f98348 // cmpq $4, %rcx + LONG $0x0126820f; WORD $0x0000 // jb LBB8_71, $294(%rip) + WORD $0x328b // movl (%rdx), %esi + LONG $0x24348941 // movl %esi, (%r12) + LONG $0x04c28348 // addq $4, %rdx + LONG $0x04c48349 // addq $4, %r12 + LONG $0xfcc18348 // addq $-4, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x0114830f; WORD $0x0000 // jae LBB8_92, $276(%rip) + +LBB8_72: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0007840f; WORD $0x0000 // je LBB8_74, $7(%rip) + +LBB8_73: + WORD $0xb60f; BYTE $0x0a // movzbl (%rdx), %ecx + LONG $0x240c8841 // movb %cl, (%r12) + +LBB8_74: + WORD $0x294d; BYTE $0xdd // subq %r11, %r13 + WORD $0x0149; BYTE $0xdd // addq %rbx, %r13 + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB8_75: + QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 + +LBB8_76: + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x0425880f; WORD $0x0000 // js LBB8_125, $1061(%rip) + WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 + WORD $0x394d; BYTE $0xee // cmpq %r13, %r14 + LONG $0x03d9840f; WORD $0x0000 // je LBB8_121, $985(%rip) + WORD $0x294d; BYTE $0xea // subq %r13, %r10 + LONG $0x000018e9; BYTE $0x00 // jmp LBB8_80, $24(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB8_79: + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x394d; BYTE $0xee // cmpq %r13, %r14 + LONG $0x03b9840f; WORD $0x0000 // je LBB8_121, $953(%rip) + +LBB8_80: + LONG $0x14b60f43; BYTE $0x2b // movzbl (%r11,%r13), %edx + LONG $0x04e2c148 // shlq $4, %rdx + LONG $0x10348b41 // movl (%r8,%rdx), %esi + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0080840f; WORD $0x0000 // je LBB8_88, $128(%rip) + WORD $0x6348; BYTE $0xce // movslq %esi, %rcx + WORD $0x2949; BYTE $0xca // subq %rcx, %r10 + LONG $0x03af8c0f; WORD $0x0000 // jl LBB8_123, $943(%rip) + LONG $0x20e6c148 // shlq $32, %rsi + WORD $0x014c; BYTE $0xc2 // addq %r8, %rdx + LONG $0x08c28348 // addq $8, %rdx + WORD $0x394c; BYTE $0xe6 // cmpq %r12, %rsi + LONG $0x002b8c0f; WORD $0x0000 // jl LBB8_84, $43(%rip) + WORD $0x028b // movl (%rdx), %eax + WORD $0x8941; BYTE $0x01 // movl %eax, (%r9) + LONG $0x04c28348 // addq $4, %rdx + LONG $0x04718d49 // leaq $4(%r9), %rsi + LONG $0xfc598d48 // leaq $-4(%rcx), %rbx + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0020830f; WORD $0x0000 // jae LBB8_85, $32(%rip) + LONG $0x00002de9; BYTE $0x00 // jmp LBB8_86, $45(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB8_84: + WORD $0x894c; BYTE $0xce // movq %r9, %rsi + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0012820f; WORD $0x0000 // jb LBB8_86, $18(%rip) + +LBB8_85: + WORD $0xb70f; BYTE $0x02 // movzwl (%rdx), %eax + WORD $0x8966; BYTE $0x06 // movw %ax, (%rsi) + LONG $0x02c28348 // addq $2, %rdx + LONG $0x02c68348 // addq $2, %rsi + LONG $0xfec38348 // addq $-2, %rbx + +LBB8_86: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xff65840f; WORD $0xffff // je LBB8_79, $-155(%rip) + WORD $0xb60f; BYTE $0x02 // movzbl (%rdx), %eax + WORD $0x0688 // movb %al, (%rsi) + LONG $0xffff5be9; BYTE $0xff // jmp LBB8_79, $-165(%rip) + +LBB8_88: + LONG $0x2b0c8d4b // leaq (%r11,%r13), %rcx + WORD $0x294d; BYTE $0xee // subq %r13, %r14 + LONG $0xf950850f; WORD $0xffff // jne LBB8_3, $-1712(%rip) + LONG $0x000311e9; BYTE $0x00 // jmp LBB8_121, $785(%rip) + +LBB8_71: + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0xfeec820f; WORD $0xffff // jb LBB8_72, $-276(%rip) + +LBB8_92: + WORD $0xb70f; BYTE $0x32 // movzwl (%rdx), %esi + LONG $0x34894166; BYTE $0x24 // movw %si, (%r12) + LONG $0x02c28348 // addq $2, %rdx + LONG $0x02c48349 // addq $2, %r12 + LONG $0xfec18348 // addq $-2, %rcx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0xfed8850f; WORD $0xffff // jne LBB8_73, $-296(%rip) + LONG $0xfffedae9; BYTE $0xff // jmp LBB8_74, $-294(%rip) + +LBB8_93: + LONG $0xe60d8d4c; WORD $0x00f7; BYTE $0x00 // leaq $63462(%rip), %r9 /* __EscTab(%rip) */ + QUAD $0xfffff80e1d6ffdc5 // vmovdqa $-2034(%rip), %ymm3 /* LCPI8_0(%rip) */ + QUAD $0xfffff826056f7dc5 // vmovdqa $-2010(%rip), %ymm8 /* LCPI8_1(%rip) */ + QUAD $0xfffff83e2d6ffdc5 // vmovdqa $-1986(%rip), %ymm5 /* LCPI8_2(%rip) */ + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + +LBB8_94: + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0x01108c0f; WORD $0x0000 // jl LBB8_102, $272(%rip) + LONG $0x20fe8348 // cmpq $32, %rsi + LONG $0x0088820f; WORD $0x0000 // jb LBB8_99, $136(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB8_96: + LONG $0x076ffec5 // vmovdqu (%rdi), %ymm0 + LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 + LONG $0xd074bdc5 // vpcmpeqb %ymm0, %ymm8, %ymm2 + LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 + LONG $0x037ffec5 // vmovdqu %ymm0, (%rbx) + LONG $0xd5dafdc5 // vpminub %ymm5, %ymm0, %ymm2 + LONG $0xc274fdc5 // vpcmpeqb %ymm2, %ymm0, %ymm0 + LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 + LONG $0xc0d7fdc5 // vpmovmskb %ymm0, %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x01ff850f; WORD $0x0000 // jne LBB8_114, $511(%rip) + LONG $0x20c78348 // addq $32, %rdi + LONG $0x20c38348 // addq $32, %rbx + LONG $0xe0c68348 // addq $-32, %rsi + LONG $0x1ffe8348 // cmpq $31, %rsi + LONG $0xffbe870f; WORD $0xffff // ja LBB8_96, $-66(%rip) + WORD $0xf8c5; BYTE $0x77 // vzeroupper + QUAD $0xfffff7d32d6ffdc5 // vmovdqa $-2093(%rip), %ymm5 /* LCPI8_2(%rip) */ + QUAD $0xfffff7ab056f7dc5 // vmovdqa $-2133(%rip), %ymm8 /* LCPI8_1(%rip) */ + QUAD $0xfffff7831d6ffdc5 // vmovdqa $-2173(%rip), %ymm3 /* LCPI8_0(%rip) */ + LONG $0x10fe8348 // cmpq $16, %rsi + QUAD $0xfffff7d7356ff9c5 // vmovdqa $-2089(%rip), %xmm6 /* LCPI8_3(%rip) */ + QUAD $0xfffff7df3d6ff9c5 // vmovdqa $-2081(%rip), %xmm7 /* LCPI8_4(%rip) */ + QUAD $0xfffff7e7256ff9c5 // vmovdqa $-2073(%rip), %xmm4 /* LCPI8_5(%rip) */ + LONG $0x0041830f; WORD $0x0000 // jae LBB8_100, $65(%rip) + LONG $0x00007ee9; BYTE $0x00 // jmp LBB8_102, $126(%rip) + +LBB8_99: + WORD $0xf8c5; BYTE $0x77 // vzeroupper + QUAD $0xfffff7912d6ffdc5 // vmovdqa $-2159(%rip), %ymm5 /* LCPI8_2(%rip) */ + QUAD $0xfffff769056f7dc5 // vmovdqa $-2199(%rip), %ymm8 /* LCPI8_1(%rip) */ + QUAD $0xfffff7411d6ffdc5 // vmovdqa $-2239(%rip), %ymm3 /* LCPI8_0(%rip) */ + QUAD $0xfffff799356ff9c5 // vmovdqa $-2151(%rip), %xmm6 /* LCPI8_3(%rip) */ + QUAD $0xfffff7a13d6ff9c5 // vmovdqa $-2143(%rip), %xmm7 /* LCPI8_4(%rip) */ + QUAD $0xfffff7a9256ff9c5 // vmovdqa $-2135(%rip), %xmm4 /* LCPI8_5(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB8_100: + LONG $0x076ffac5 // vmovdqu (%rdi), %xmm0 + LONG $0xce74f9c5 // vpcmpeqb %xmm6, %xmm0, %xmm1 + LONG $0xd774f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm2 + LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 + LONG $0x037ffac5 // vmovdqu %xmm0, (%rbx) + LONG $0xd4daf9c5 // vpminub %xmm4, %xmm0, %xmm2 + LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 + LONG $0xc0ebf1c5 // vpor %xmm0, %xmm1, %xmm0 + LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x0130850f; WORD $0x0000 // jne LBB8_112, $304(%rip) + LONG $0x10c78348 // addq $16, %rdi + LONG $0x10c38348 // addq $16, %rbx + LONG $0xf0c68348 // addq $-16, %rsi + LONG $0x0ffe8348 // cmpq $15, %rsi + LONG $0xffbe870f; WORD $0xffff // ja LBB8_100, $-66(%rip) + +LBB8_102: + LONG $0x08fe8348 // cmpq $8, %rsi + LONG $0x00818c0f; WORD $0x0000 // jl LBB8_106, $129(%rip) + WORD $0xb60f; BYTE $0x07 // movzbl (%rdi), %eax + LONG $0x014fb60f // movzbl $1(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xc900 // addb %cl, %cl + LONG $0x080c0a42 // orb (%rax,%r9), %cl + LONG $0x0247b60f // movzbl $2(%rdi), %eax + LONG $0x14b60f46; BYTE $0x08 // movzbl (%rax,%r9), %r10d + LONG $0x02e2c041 // shlb $2, %r10b + WORD $0x0841; BYTE $0xca // orb %cl, %r10b + LONG $0x0347b60f // movzbl $3(%rdi), %eax + LONG $0x04b60f42; BYTE $0x08 // movzbl (%rax,%r9), %eax + WORD $0xe0c0; BYTE $0x03 // shlb $3, %al + WORD $0x0844; BYTE $0xd0 // orb %r10b, %al + WORD $0x8b48; BYTE $0x0f // movq (%rdi), %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + LONG $0x00df850f; WORD $0x0000 // jne LBB8_113, $223(%rip) + LONG $0x0447b60f // movzbl $4(%rdi), %eax + LONG $0x054fb60f // movzbl $5(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xc900 // addb %cl, %cl + LONG $0x080c0a42 // orb (%rax,%r9), %cl + LONG $0x0647b60f // movzbl $6(%rdi), %eax + LONG $0x14b60f46; BYTE $0x08 // movzbl (%rax,%r9), %r10d + LONG $0x02e2c041 // shlb $2, %r10b + WORD $0x0841; BYTE $0xca // orb %cl, %r10b + LONG $0x0747b60f // movzbl $7(%rdi), %eax + LONG $0x04b60f42; BYTE $0x08 // movzbl (%rax,%r9), %eax + WORD $0xe0c0; BYTE $0x03 // shlb $3, %al + WORD $0x0844; BYTE $0xd0 // orb %r10b, %al + LONG $0x00fc850f; WORD $0x0000 // jne LBB8_119, $252(%rip) + LONG $0x08c38348 // addq $8, %rbx + LONG $0x08c78348 // addq $8, %rdi + LONG $0xf8c68348 // addq $-8, %rsi + +LBB8_106: + LONG $0x04fe8348 // cmpq $4, %rsi + LONG $0x00478c0f; WORD $0x0000 // jl LBB8_109, $71(%rip) + WORD $0xb60f; BYTE $0x07 // movzbl (%rdi), %eax + LONG $0x014fb60f // movzbl $1(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xc900 // addb %cl, %cl + LONG $0x080c0a42 // orb (%rax,%r9), %cl + LONG $0x0247b60f // movzbl $2(%rdi), %eax + LONG $0x14b60f46; BYTE $0x08 // movzbl (%rax,%r9), %r10d + LONG $0x02e2c041 // shlb $2, %r10b + WORD $0x0841; BYTE $0xca // orb %cl, %r10b + LONG $0x0347b60f // movzbl $3(%rdi), %eax + LONG $0x04b60f42; BYTE $0x08 // movzbl (%rax,%r9), %eax + WORD $0xe0c0; BYTE $0x03 // shlb $3, %al + WORD $0x0844; BYTE $0xd0 // orb %r10b, %al + WORD $0x0f8b // movl (%rdi), %ecx + WORD $0x0b89 // movl %ecx, (%rbx) + LONG $0x0056850f; WORD $0x0000 // jne LBB8_113, $86(%rip) + LONG $0x04c38348 // addq $4, %rbx + LONG $0x04c78348 // addq $4, %rdi + LONG $0xfcc68348 // addq $-4, %rsi + +LBB8_109: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x00b68e0f; WORD $0x0000 // jle LBB8_120, $182(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB8_110: + WORD $0xb60f; BYTE $0x07 // movzbl (%rdi), %eax + LONG $0x083c8042; BYTE $0x00 // cmpb $0, (%rax,%r9) + LONG $0x0039850f; WORD $0x0000 // jne LBB8_116, $57(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0x0388 // movb %al, (%rbx) + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xff468d48 // leaq $-1(%rsi), %rax + LONG $0x01fe8348 // cmpq $1, %rsi + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + LONG $0xffd98f0f; WORD $0xffff // jg LBB8_110, $-39(%rip) + LONG $0x000081e9; BYTE $0x00 // jmp LBB8_120, $129(%rip) + +LBB8_112: + LONG $0xc0bc0f66 // bsfw %ax, %ax + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0x000006e9; BYTE $0x00 // jmp LBB8_115, $6(%rip) + +LBB8_113: + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + +LBB8_114: + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax + +LBB8_115: + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + +LBB8_116: + WORD $0xb60f; BYTE $0x07 // movzbl (%rdi), %eax + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB8_117: + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + LONG $0x04e0c148 // shlq $4, %rax + LONG $0x001c6349 // movslq (%r8,%rax), %rbx + LONG $0x00448b49; BYTE $0x08 // movq $8(%r8,%rax), %rax + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x003a8c0f; WORD $0x0000 // jl LBB8_120, $58(%rip) + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x0147b60f // movzbl $1(%rdi), %eax + WORD $0xff48; BYTE $0xc7 // incq %rdi + LONG $0x083c8042; BYTE $0x00 // cmpb $0, (%rax,%r9) + LONG $0xffc8850f; WORD $0xffff // jne LBB8_117, $-56(%rip) + LONG $0xfffd6be9; BYTE $0xff // jmp LBB8_94, $-661(%rip) + +LBB8_119: + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax + LONG $0x04488d48 // leaq $4(%rax), %rcx + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + LONG $0x04c78348 // addq $4, %rdi + WORD $0x2948; BYTE $0xce // subq %rcx, %rsi + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + LONG $0x04c38348 // addq $4, %rbx + LONG $0xffff9ae9; BYTE $0xff // jmp LBB8_116, $-102(%rip) + +LBB8_120: + WORD $0x2948; BYTE $0xd3 // subq %rdx, %rbx + WORD $0x8949; BYTE $0x1f // movq %rbx, (%r15) + LONG $0x00002be9; BYTE $0x00 // jmp LBB8_124, $43(%rip) + +LBB8_121: + WORD $0x014d; BYTE $0xeb // addq %r13, %r11 + LONG $0xc0558b48 // movq $-64(%rbp), %rdx + +LBB8_122: + WORD $0x2949; BYTE $0xd1 // subq %rdx, %r9 + WORD $0x894d; BYTE $0x0f // movq %r9, (%r15) + WORD $0x2949; BYTE $0xfb // subq %rdi, %r11 + WORD $0x894d; BYTE $0xde // movq %r11, %r14 + LONG $0x000013e9; BYTE $0x00 // jmp LBB8_124, $19(%rip) + +LBB8_123: + LONG $0xc04d2b4c // subq $-64(%rbp), %r9 + WORD $0x894d; BYTE $0x0f // movq %r9, (%r15) + WORD $0x294c; BYTE $0xdf // subq %r11, %rdi + WORD $0xf749; BYTE $0xd5 // notq %r13 + WORD $0x0149; BYTE $0xfd // addq %rdi, %r13 + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + +LBB8_124: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + LONG $0x18c48348 // addq $24, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB8_125: + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xc8 // addq %r9, %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + WORD $0x294c; BYTE $0xdf // subq %r11, %rdi + WORD $0x014c; BYTE $0xef // addq %r13, %rdi + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + LONG $0xffffcde9; BYTE $0xff // jmp LBB8_124, $-51(%rip) + QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; WORD $0x0000 // .p2align 5, 0x00 + +LCPI9_0: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + + // .p2align 4, 0x00 +LCPI9_1: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI9_2: + BYTE $0xf0 // .byte 240 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + + // .p2align 4, 0x90 +_unquote: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x48ec8348 // subq $72, %rsp + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x070f840f; WORD $0x0000 // je LBB9_1, $1807(%rip) + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0xa045894c // movq %r8, $-96(%rbp) + WORD $0x894d; BYTE $0xc2 // movq %r8, %r10 + LONG $0x01e28341 // andl $1, %r10d + LONG $0x1d058d4c; WORD $0x00f5; BYTE $0x00 // leaq $62749(%rip), %r8 /* __UnquoteTab(%rip) */ + QUAD $0xffffff850d6ffdc5 // vmovdqa $-123(%rip), %ymm1 /* LCPI9_0(%rip) */ + QUAD $0xffffff9d156ff9c5 // vmovdqa $-99(%rip), %xmm2 /* LCPI9_1(%rip) */ + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + LONG $0x00021fe9; BYTE $0x00 // jmp LBB9_3, $543(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_59: + LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d + LONG $0x0573860f; WORD $0x0000 // jbe LBB9_67, $1395(%rip) + QUAD $0xffff200024848d41 // leal $-57344(%r12), %eax + LONG $0xfff7ff3d; BYTE $0xff // cmpl $-2049, %eax + LONG $0x0520860f; WORD $0x0000 // jbe LBB9_70, $1312(%rip) + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xc07d8948 // movq %rdi, $-64(%rbp) + LONG $0xb8758948 // movq %rsi, $-72(%rbp) + LONG $0x00dc850f; WORD $0x0000 // jne LBB9_62, $220(%rip) + LONG $0xb055894c // movq %r10, $-80(%rbp) + LONG $0xa8558948 // movq %rdx, $-88(%rbp) + LONG $0x06fd8349 // cmpq $6, %r13 + LONG $0x00f58c0f; WORD $0x0000 // jl LBB9_94, $245(%rip) + +LBB9_91: + LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d + LONG $0x00e8870f; WORD $0x0000 // ja LBB9_94, $232(%rip) + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x00de850f; WORD $0x0000 // jne LBB9_94, $222(%rip) + LONG $0x017f8041; BYTE $0x75 // cmpb $117, $1(%r15) + LONG $0x00d3850f; WORD $0x0000 // jne LBB9_94, $211(%rip) + LONG $0x025f8b41 // movl $2(%r15), %ebx + WORD $0xdf89 // movl %ebx, %edi + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x0008ade8; BYTE $0x00 // callq _unhex16_is, $2221(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x0798840f; WORD $0x0000 // je LBB9_100, $1944(%rip) + WORD $0xcb0f // bswapl %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx + WORD $0xc301 // addl %eax, %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xd809 // orl %ebx, %eax + WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx + WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax + LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax + WORD $0x1c8d; BYTE $0x08 // leal (%rax,%rcx), %ebx + LONG $0x06c78349 // addq $6, %r15 + LONG $0xfac58349 // addq $-6, %r13 + WORD $0xc801 // addl %ecx, %eax + LONG $0xff200005; BYTE $0xff // addl $-57344, %eax + LONG $0xfffbff3d; BYTE $0xff // cmpl $-1025, %eax + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + LONG $0xa8558b48 // movq $-88(%rbp), %rdx + LONG $0xb8758b48 // movq $-72(%rbp), %rsi + LONG $0x20058d4c; WORD $0x00f4; BYTE $0x00 // leaq $62496(%rip), %r8 /* __UnquoteTab(%rip) */ + QUAD $0xfffffe880d6ffdc5 // vmovdqa $-376(%rip), %ymm1 /* LCPI9_0(%rip) */ + QUAD $0xfffffea0156ff9c5 // vmovdqa $-352(%rip), %xmm2 /* LCPI9_1(%rip) */ + LONG $0x0070870f; WORD $0x0000 // ja LBB9_110, $112(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx + LONG $0xb0558b4c // movq $-80(%rbp), %r10 + LONG $0xfef8830f; WORD $0xffff // jae LBB9_59, $-264(%rip) + LONG $0x0003f8e9; BYTE $0x00 // jmp LBB9_112, $1016(%rip) + +LBB9_62: + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x06d88e0f; WORD $0x0000 // jle LBB9_63, $1752(%rip) + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x00c5850f; WORD $0x0000 // jne LBB9_96, $197(%rip) + WORD $0xff49; BYTE $0xcd // decq %r13 + WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0xb055894c // movq %r10, $-80(%rbp) + LONG $0xa8558948 // movq %rdx, $-88(%rbp) + LONG $0x06fd8349 // cmpq $6, %r13 + LONG $0xff0b8d0f; WORD $0xffff // jge LBB9_91, $-245(%rip) + +LBB9_94: + LONG $0x02a045f6 // testb $2, $-96(%rbp) + LONG $0x0565840f; WORD $0x0000 // je LBB9_77, $1381(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + LONG $0x00005ae9; BYTE $0x00 // jmp LBB9_86, $90(%rip) + +LBB9_110: + WORD $0xd889 // movl %ebx, %eax + +LBB9_85: + LONG $0x0ae4c141 // shll $10, %r12d + WORD $0xc189 // movl %eax, %ecx + WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx + WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax + LONG $0xa0240005; BYTE $0xfc // addl $-56613888, %eax + WORD $0xc289 // movl %eax, %edx + WORD $0xeac1; BYTE $0x12 // shrl $18, %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xeec1; BYTE $0x0c // shrl $12, %esi + LONG $0x3fe68040 // andb $63, %sil + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + LONG $0xc26ef9c5 // vmovd %edx, %xmm0 + LONG $0xd6b60f40 // movzbl %sil, %edx + LONG $0x2079e3c4; WORD $0x01c2 // vpinsrb $1, %edx, %xmm0, %xmm0 + WORD $0x3f24 // andb $63, %al + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + LONG $0x2079e3c4; WORD $0x02c0 // vpinsrb $2, %eax, %xmm0, %xmm0 + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax + LONG $0x2079e3c4; WORD $0x03c0 // vpinsrb $3, %eax, %xmm0, %xmm0 + QUAD $0xfffffde905ebf9c5 // vpor $-535(%rip), %xmm0, %xmm0 /* LCPI9_2(%rip) */ + LONG $0x7e79c1c4; BYTE $0x06 // vmovd %xmm0, (%r14) + LONG $0x04c68349 // addq $4, %r14 + +LBB9_86: + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + LONG $0xa8558b48 // movq $-88(%rbp), %rdx + LONG $0xb0558b4c // movq $-80(%rbp), %r10 + LONG $0xb8758b48 // movq $-72(%rbp), %rsi + LONG $0x29058d4c; WORD $0x00f3; BYTE $0x00 // leaq $62249(%rip), %r8 /* __UnquoteTab(%rip) */ + QUAD $0xfffffd910d6ffdc5 // vmovdqa $-623(%rip), %ymm1 /* LCPI9_0(%rip) */ + QUAD $0xfffffda9156ff9c5 // vmovdqa $-599(%rip), %xmm2 /* LCPI9_1(%rip) */ + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x0030850f; WORD $0x0000 // jne LBB9_3, $48(%rip) + LONG $0x000622e9; BYTE $0x00 // jmp LBB9_115, $1570(%rip) + +LBB9_96: + LONG $0x02a045f6 // testb $2, $-96(%rbp) + LONG $0x0705840f; WORD $0x0000 // je LBB9_97, $1797(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + LONG $0xb8758b48 // movq $-72(%rbp), %rsi + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x05f8840f; WORD $0x0000 // je LBB9_115, $1528(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB9_3: + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x0016850f; WORD $0x0000 // jne LBB9_5, $22(%rip) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0x00015ee9; BYTE $0x00 // jmp LBB9_23, $350(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB9_5: + WORD $0x894c; BYTE $0xeb // movq %r13, %rbx + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + WORD $0x894d; BYTE $0xf9 // movq %r15, %r9 + LONG $0x20fd8349 // cmpq $32, %r13 + LONG $0x00458c0f; WORD $0x0000 // jl LBB9_11, $69(%rip) + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB9_7: + LONG $0x6f7ec1c4; WORD $0x0f04 // vmovdqu (%r15,%rcx), %ymm0 + LONG $0x7f7ec1c4; WORD $0x0e04 // vmovdqu %ymm0, (%r14,%rcx) + LONG $0xc174fdc5 // vpcmpeqb %ymm1, %ymm0, %ymm0 + LONG $0xd8d7fdc5 // vpmovmskb %ymm0, %ebx + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x00db850f; WORD $0x0000 // jne LBB9_8, $219(%rip) + LONG $0xe0588d48 // leaq $-32(%rax), %rbx + LONG $0x20c18348 // addq $32, %rcx + LONG $0x3ff88348 // cmpq $63, %rax + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0xffcf8f0f; WORD $0xffff // jg LBB9_7, $-49(%rip) + LONG $0x0f0c8d4d // leaq (%r15,%rcx), %r9 + WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + +LBB9_11: + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x10fb8348 // cmpq $16, %rbx + LONG $0x00568c0f; WORD $0x0000 // jl LBB9_12, $86(%rip) + WORD $0x894d; BYTE $0xfb // movq %r15, %r11 + WORD $0x294d; BYTE $0xcb // subq %r9, %r11 + QUAD $0xfffffcbd0d6ffdc5 // vmovdqa $-835(%rip), %ymm1 /* LCPI9_0(%rip) */ + QUAD $0xfffffcd5156ff9c5 // vmovdqa $-811(%rip), %xmm2 /* LCPI9_1(%rip) */ + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_18: + LONG $0x6f7ac1c4; BYTE $0x01 // vmovdqu (%r9), %xmm0 + LONG $0x017ffac5 // vmovdqu %xmm0, (%rcx) + LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 + LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x0094850f; WORD $0x0000 // jne LBB9_19, $148(%rip) + LONG $0x10c18349 // addq $16, %r9 + LONG $0x10c18348 // addq $16, %rcx + LONG $0xf0638d4c // leaq $-16(%rbx), %r12 + LONG $0xf0c38349 // addq $-16, %r11 + LONG $0x1ffb8348 // cmpq $31, %rbx + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0xffca870f; WORD $0xffff // ja LBB9_18, $-54(%rip) + LONG $0x000013e9; BYTE $0x00 // jmp LBB9_13, $19(%rip) + +LBB9_12: + WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 + QUAD $0xfffffc6a0d6ffdc5 // vmovdqa $-918(%rip), %ymm1 /* LCPI9_0(%rip) */ + QUAD $0xfffffc82156ff9c5 // vmovdqa $-894(%rip), %xmm2 /* LCPI9_1(%rip) */ + +LBB9_13: + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x03c8840f; WORD $0x0000 // je LBB9_116, $968(%rip) + WORD $0xc031 // xorl %eax, %eax + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_15: + LONG $0x1cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ebx + WORD $0xfb80; BYTE $0x5c // cmpb $92, %bl + LONG $0x0014840f; WORD $0x0000 // je LBB9_21, $20(%rip) + WORD $0x1c88; BYTE $0x01 // movb %bl, (%rcx,%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0xffe3850f; WORD $0xffff // jne LBB9_15, $-29(%rip) + LONG $0x00039de9; BYTE $0x00 // jmp LBB9_116, $925(%rip) + +LBB9_21: + WORD $0x294d; BYTE $0xf9 // subq %r15, %r9 + WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x003e850f; WORD $0x0000 // jne LBB9_23, $62(%rip) + LONG $0x000388e9; BYTE $0x00 // jmp LBB9_116, $904(%rip) + +LBB9_8: + LONG $0xcbbc0f44 // bsfl %ebx, %r9d + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x0028850f; WORD $0x0000 // jne LBB9_23, $40(%rip) + LONG $0x000372e9; BYTE $0x00 // jmp LBB9_116, $882(%rip) + +LBB9_19: + LONG $0xc0bc0f66 // bsfw %ax, %ax + LONG $0xc8b70f44 // movzwl %ax, %r9d + WORD $0x294d; BYTE $0xd9 // subq %r11, %r9 + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x035d840f; WORD $0x0000 // je LBB9_116, $861(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB9_23: + LONG $0x02498d49 // leaq $2(%r9), %rcx + WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 + LONG $0x0411880f; WORD $0x0000 // js LBB9_24, $1041(%rip) + WORD $0x014d; BYTE $0xcf // addq %r9, %r15 + LONG $0x02c78349 // addq $2, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0112850f; WORD $0x0000 // jne LBB9_26, $274(%rip) + +LBB9_37: + WORD $0x014d; BYTE $0xce // addq %r9, %r14 + LONG $0x47b60f41; BYTE $0xff // movzbl $-1(%r15), %eax + LONG $0x04b60f42; BYTE $0x00 // movzbl (%rax,%r8), %eax + LONG $0x0000ff3d; BYTE $0x00 // cmpl $255, %eax + LONG $0x002b840f; WORD $0x0000 // je LBB9_41, $43(%rip) + WORD $0xc085 // testl %eax, %eax + LONG $0x03f4840f; WORD $0x0000 // je LBB9_39, $1012(%rip) + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + +LBB9_113: + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfe44850f; WORD $0xffff // jne LBB9_3, $-444(%rip) + LONG $0x000436e9; BYTE $0x00 // jmp LBB9_115, $1078(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_41: + LONG $0x03fd8349 // cmpq $3, %r13 + LONG $0x03b4860f; WORD $0x0000 // jbe LBB9_24, $948(%rip) + WORD $0x8b41; BYTE $0x1f // movl (%r15), %ebx + WORD $0xd989 // movl %ebx, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0xcfd0838d; WORD $0xcfcf // leal $-808464432(%rbx), %eax + LONG $0x8080e181; WORD $0x8080 // andl $-2139062144, %ecx + WORD $0xc185 // testl %eax, %ecx + LONG $0x02e5850f; WORD $0x0000 // jne LBB9_46, $741(%rip) + LONG $0x1919838d; WORD $0x1919 // leal $421075225(%rbx), %eax + WORD $0xd809 // orl %ebx, %eax + LONG $0x808080a9; BYTE $0x80 // testl $-2139062144, %eax + LONG $0x02d2850f; WORD $0x0000 // jne LBB9_46, $722(%rip) + WORD $0xd889 // movl %ebx, %eax + LONG $0x7f7f7f25; BYTE $0x7f // andl $2139062143, %eax + LONG $0xc0c0bb41; WORD $0xc0c0 // movl $-1061109568, %r11d + WORD $0x2941; BYTE $0xc3 // subl %eax, %r11d + LONG $0x46888d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rax), %r9d + WORD $0x2141; BYTE $0xcb // andl %ecx, %r11d + WORD $0x8545; BYTE $0xcb // testl %r9d, %r11d + LONG $0x02af850f; WORD $0x0000 // jne LBB9_46, $687(%rip) + LONG $0xe0e0b941; WORD $0xe0e0 // movl $-522133280, %r9d + WORD $0x2941; BYTE $0xc1 // subl %eax, %r9d + LONG $0x39393905; BYTE $0x39 // addl $960051513, %eax + WORD $0x2144; BYTE $0xc9 // andl %r9d, %ecx + WORD $0xc185 // testl %eax, %ecx + LONG $0x0296850f; WORD $0x0000 // jne LBB9_46, $662(%rip) + WORD $0xcb0f // bswapl %ebx + WORD $0xd989 // movl %ebx, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + LONG $0x0101e181; WORD $0x0101 // andl $16843009, %ecx + WORD $0x0c8d; BYTE $0xc9 // leal (%rcx,%rcx,8), %ecx + LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx + WORD $0xcb01 // addl %ecx, %ebx + WORD $0xd989 // movl %ebx, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xd909 // orl %ebx, %ecx + WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx + LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx + WORD $0xcb09 // orl %ecx, %ebx + LONG $0x044f8d4d // leaq $4(%r15), %r9 + LONG $0xfc4d8d49 // leaq $-4(%r13), %rcx + LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx + LONG $0x0068820f; WORD $0x0000 // jb LBB9_56, $104(%rip) + LONG $0x02a045f6 // testb $2, $-96(%rbp) + LONG $0x006c840f; WORD $0x0000 // je LBB9_65, $108(%rip) + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + LONG $0xfffb51e9; BYTE $0xff // jmp LBB9_59, $-1199(%rip) + +LBB9_26: + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x02e6840f; WORD $0x0000 // je LBB9_24, $742(%rip) + LONG $0xff7f8041; BYTE $0x5c // cmpb $92, $-1(%r15) + LONG $0x0307850f; WORD $0x0000 // jne LBB9_28, $775(%rip) + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x0027850f; WORD $0x0000 // jne LBB9_36, $39(%rip) + LONG $0x01fd8341 // cmpl $1, %r13d + LONG $0x02c78e0f; WORD $0x0000 // jle LBB9_24, $711(%rip) + LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx + WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx + LONG $0x0009840f; WORD $0x0000 // je LBB9_35, $9(%rip) + WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx + LONG $0x02f5850f; WORD $0x0000 // jne LBB9_34, $757(%rip) + +LBB9_35: + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xff49; BYTE $0xcd // decq %r13 + +LBB9_36: + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xff49; BYTE $0xcd // decq %r13 + LONG $0xfffe9ee9; BYTE $0xff // jmp LBB9_37, $-354(%rip) + +LBB9_56: + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + +LBB9_112: + WORD $0x8841; BYTE $0x1e // movb %bl, (%r14) + LONG $0xfffeb3e9; BYTE $0xff // jmp LBB9_113, $-333(%rip) + +LBB9_65: + LONG $0x0800fb81; WORD $0x0000 // cmpl $2048, %ebx + LONG $0x005e820f; WORD $0x0000 // jb LBB9_66, $94(%rip) + LONG $0x2000838d; WORD $0xffff // leal $-57344(%rbx), %eax + LONG $0xfff8003d; BYTE $0xff // cmpl $-2048, %eax + LONG $0x007f830f; WORD $0x0000 // jae LBB9_71, $127(%rip) + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_70: + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + WORD $0xe8c1; BYTE $0x0c // shrl $12, %eax + WORD $0xe00c // orb $-32, %al + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x01468841 // movb %al, $1(%r14) + LONG $0x3fe48041 // andb $63, %r12b + LONG $0x80cc8041 // orb $-128, %r12b + LONG $0x02668845 // movb %r12b, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfc9e850f; WORD $0xffff // jne LBB9_3, $-866(%rip) + LONG $0x000290e9; BYTE $0x00 // jmp LBB9_115, $656(%rip) + +LBB9_66: + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + +LBB9_67: + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0xc00c // orb $-64, %al + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + LONG $0x3fe48041 // andb $63, %r12b + LONG $0x80cc8041 // orb $-128, %r12b + LONG $0x01668845 // movb %r12b, $1(%r14) + LONG $0x02c68349 // addq $2, %r14 + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfc6c850f; WORD $0xffff // jne LBB9_3, $-916(%rip) + LONG $0x00025ee9; BYTE $0x00 // jmp LBB9_115, $606(%rip) + +LBB9_71: + WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 + LONG $0x984d8948 // movq %rcx, $-104(%rbp) + LONG $0xc84d894c // movq %r9, $-56(%rbp) + LONG $0xb8758948 // movq %rsi, $-72(%rbp) + LONG $0xa8558948 // movq %rdx, $-88(%rbp) + LONG $0xc07d8948 // movq %rdi, $-64(%rbp) + LONG $0xb055894c // movq %r10, $-80(%rbp) + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x00a4850f; WORD $0x0000 // jne LBB9_72, $164(%rip) + LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) + LONG $0x00cb820f; WORD $0x0000 // jb LBB9_76, $203(%rip) + +LBB9_78: + LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d + LONG $0x00be870f; WORD $0x0000 // ja LBB9_76, $190(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) + LONG $0x00b1850f; WORD $0x0000 // jne LBB9_76, $177(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + LONG $0x75017880 // cmpb $117, $1(%rax) + LONG $0x00a3850f; WORD $0x0000 // jne LBB9_76, $163(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x588b; BYTE $0x02 // movl $2(%rax), %ebx + WORD $0xdf89 // movl %ebx, %edi + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x00030fe8; BYTE $0x00 // callq _unhex16_is, $783(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x01f6840f; WORD $0x0000 // je LBB9_82, $502(%rip) + WORD $0xcb0f // bswapl %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx + WORD $0xc301 // addl %eax, %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xd809 // orl %ebx, %eax + WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx + WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax + LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax + LONG $0xc8458348; BYTE $0x06 // addq $6, $-56(%rbp) + WORD $0x148d; BYTE $0x08 // leal (%rax,%rcx), %edx + LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx + LONG $0xfc00fa81; WORD $0xffff // cmpl $-1024, %edx + LONG $0x029a820f; WORD $0x0000 // jb LBB9_98, $666(%rip) + WORD $0xc809 // orl %ecx, %eax + LONG $0x986d8b4c // movq $-104(%rbp), %r13 + LONG $0xfac58349 // addq $-6, %r13 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + LONG $0xfffae7e9; BYTE $0xff // jmp LBB9_85, $-1305(%rip) + +LBB9_72: + LONG $0x05fd8349 // cmpq $5, %r13 + LONG $0x0262820f; WORD $0x0000 // jb LBB9_87, $610(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) + LONG $0x0270850f; WORD $0x0000 // jne LBB9_98, $624(%rip) + LONG $0xfbc58349 // addq $-5, %r13 + LONG $0x05c78349 // addq $5, %r15 + LONG $0x986d894c // movq %r13, $-104(%rbp) + LONG $0xc87d894c // movq %r15, $-56(%rbp) + LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) + LONG $0xff35830f; WORD $0xffff // jae LBB9_78, $-203(%rip) + +LBB9_76: + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + +LBB9_77: + LONG $0xb0458b48 // movq $-80(%rbp), %rax + LONG $0xc0450348 // addq $-64(%rbp), %rax + WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 + LONG $0xfcc78349 // addq $-4, %r15 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 + LONG $0x00000ce9; BYTE $0x00 // jmp LBB9_117, $12(%rip) + +LBB9_1: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + +LBB9_116: + WORD $0x014d; BYTE $0xee // addq %r13, %r14 + WORD $0x2949; BYTE $0xd6 // subq %rdx, %r14 + +LBB9_117: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + LONG $0x48c48348 // addq $72, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB9_46: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + LONG $0xd0758b48 // movq $-48(%rbp), %rsi + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0x0fb60f41 // movzbl (%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_48, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xffb8820f; WORD $0xffff // jb LBB9_117, $-72(%rip) + +LBB9_48: + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_50, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xff91820f; WORD $0xffff // jb LBB9_117, $-111(%rip) + +LBB9_50: + LONG $0x02488d48 // leaq $2(%rax), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_52, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xff6a820f; WORD $0xffff // jb LBB9_117, $-150(%rip) + +LBB9_52: + LONG $0x03488d48 // leaq $3(%rax), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_54, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xff43820f; WORD $0xffff // jb LBB9_117, $-189(%rip) + +LBB9_54: + LONG $0x04c08348 // addq $4, %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xffff37e9; BYTE $0xff // jmp LBB9_117, $-201(%rip) + +LBB9_24: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + LONG $0xffff24e9; BYTE $0xff // jmp LBB9_117, $-220(%rip) + +LBB9_39: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0149; BYTE $0xff // addq %rdi, %r15 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + LONG $0xfdc6c749; WORD $0xffff; BYTE $0xff // movq $-3, %r14 + LONG $0xffff0be9; BYTE $0xff // jmp LBB9_117, $-245(%rip) + +LBB9_28: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0149; BYTE $0xff // addq %rdi, %r15 + +LBB9_29: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + LONG $0xfffef2e9; BYTE $0xff // jmp LBB9_117, $-270(%rip) + +LBB9_34: + WORD $0x2949; BYTE $0xff // subq %rdi, %r15 + WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB9_29, $-30(%rip) + +LBB9_63: + LONG $0x02a045f6 // testb $2, $-96(%rbp) + LONG $0x00e5840f; WORD $0x0000 // je LBB9_87, $229(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + +LBB9_115: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + LONG $0xfffec0e9; BYTE $0xff // jmp LBB9_116, $-320(%rip) + +LBB9_82: + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + +LBB9_100: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0xc0452b48 // subq $-64(%rbp), %rax + LONG $0x02c08348 // addq $2, %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_102, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe89820f; WORD $0xffff // jb LBB9_117, $-375(%rip) + +LBB9_102: + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_104, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe5e820f; WORD $0xffff // jb LBB9_117, $-418(%rip) + +LBB9_104: + LONG $0x02488d48 // leaq $2(%rax), %rcx + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x4fb60f41; BYTE $0x04 // movzbl $4(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_106, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe33820f; WORD $0xffff // jb LBB9_117, $-461(%rip) + +LBB9_106: + LONG $0x03488d48 // leaq $3(%rax), %rcx + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x4fb60f41; BYTE $0x05 // movzbl $5(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_108, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe08820f; WORD $0xffff // jb LBB9_117, $-504(%rip) + +LBB9_108: + LONG $0x04c08348 // addq $4, %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xfffdf8e9; BYTE $0xff // jmp LBB9_117, $-520(%rip) + +LBB9_87: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + LONG $0xfffde1e9; BYTE $0xff // jmp LBB9_117, $-543(%rip) + +LBB9_97: + LONG $0xc87d894c // movq %r15, $-56(%rbp) + +LBB9_98: + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0xc0652b4c // subq $-64(%rbp), %r12 + LONG $0xfcc48349 // addq $-4, %r12 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x20 // movq %r12, (%rax) + LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 + LONG $0xfffdbee9; BYTE $0xff // jmp LBB9_117, $-578(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +_unhex16_is: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0xf889 // movl %edi, %eax + WORD $0xd0f7 // notl %eax + LONG $0xcfd08f8d; WORD $0xcfcf // leal $-808464432(%rdi), %ecx + LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax + WORD $0xc885 // testl %ecx, %eax + LONG $0x0007840f; WORD $0x0000 // je LBB10_2, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB10_2: + LONG $0x19198f8d; WORD $0x1919 // leal $421075225(%rdi), %ecx + WORD $0xf909 // orl %edi, %ecx + LONG $0x8080c1f7; WORD $0x8080 // testl $-2139062144, %ecx + LONG $0x0007840f; WORD $0x0000 // je LBB10_4, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB10_4: + LONG $0x7f7fe781; WORD $0x7f7f // andl $2139062143, %edi + LONG $0xc0c0c0b9; BYTE $0xc0 // movl $-1061109568, %ecx + WORD $0xf929 // subl %edi, %ecx + LONG $0x4646978d; WORD $0x4646 // leal $1179010630(%rdi), %edx + WORD $0xc121 // andl %eax, %ecx + WORD $0xd185 // testl %edx, %ecx + LONG $0x0007840f; WORD $0x0000 // je LBB10_6, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB10_6: + LONG $0xe0e0e0b9; BYTE $0xe0 // movl $-522133280, %ecx + WORD $0xf929 // subl %edi, %ecx + LONG $0x3939c781; WORD $0x3939 // addl $960051513, %edi + WORD $0xc821 // andl %ecx, %eax + WORD $0xf885 // testl %edi, %eax + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 + +LCPI11_0: + QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&' + QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&' + +LCPI11_1: + QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2' + QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2' + +LCPI11_2: + QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd' + QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd' + +LCPI11_3: + QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<' + QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<' + + // .p2align 4, 0x00 +LCPI11_4: + QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&' + +LCPI11_5: + QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2' + +LCPI11_6: + QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd' + +LCPI11_7: + QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<' + + // .p2align 4, 0x90 +_html_escape: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x18ec8348 // subq $24, %rsp + LONG $0xc04d8948 // movq %rcx, $-64(%rbp) + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0xc8558948 // movq %rdx, $-56(%rbp) + LONG $0xd07d8948 // movq %rdi, $-48(%rbp) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x07e98e0f; WORD $0x0000 // jle LBB11_105, $2025(%rip) + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x8b4c; BYTE $0x08 // movq (%rax), %r9 + QUAD $0xffffff051d6ffdc5 // vmovdqa $-251(%rip), %ymm3 /* LCPI11_0(%rip) */ + QUAD $0xffffff1d256ffdc5 // vmovdqa $-227(%rip), %ymm4 /* LCPI11_1(%rip) */ + QUAD $0xffffff352d6ffdc5 // vmovdqa $-203(%rip), %ymm5 /* LCPI11_2(%rip) */ + QUAD $0xffffff4d356ffdc5 // vmovdqa $-179(%rip), %ymm6 /* LCPI11_3(%rip) */ + LONG $0x362d8d4c; WORD $0x00eb; BYTE $0x00 // leaq $60214(%rip), %r13 /* __HtmlQuoteTab(%rip) */ + LONG $0xd05d8b4c // movq $-48(%rbp), %r11 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB11_2: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x07bb8e0f; WORD $0x0000 // jle LBB11_3, $1979(%rip) + LONG $0x20fe8348 // cmpq $32, %rsi + WORD $0x930f; BYTE $0xc1 // setae %cl + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0x894d; BYTE $0xf8 // movq %r15, %r8 + WORD $0x8949; BYTE $0xf2 // movq %rsi, %r10 + WORD $0x894d; BYTE $0xdc // movq %r11, %r12 + LONG $0x20f98349 // cmpq $32, %r9 + LONG $0x007a820f; WORD $0x0000 // jb LBB11_12, $122(%rip) + LONG $0x20fe8348 // cmpq $32, %rsi + LONG $0x0070820f; WORD $0x0000 // jb LBB11_12, $112(%rip) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x894c; BYTE $0xcf // movq %r9, %rdi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_7: + LONG $0x6f7e81c4; WORD $0x0304 // vmovdqu (%r11,%r8), %ymm0 + LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 + LONG $0xd474fdc5 // vpcmpeqb %ymm4, %ymm0, %ymm2 + LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 + LONG $0xd5dbfdc5 // vpand %ymm5, %ymm0, %ymm2 + LONG $0xd674edc5 // vpcmpeqb %ymm6, %ymm2, %ymm2 + LONG $0xcaebf5c5 // vpor %ymm2, %ymm1, %ymm1 + LONG $0x7f7e81c4; WORD $0x0704 // vmovdqu %ymm0, (%r15,%r8) + LONG $0xc1d7fdc5 // vpmovmskb %ymm1, %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x0180850f; WORD $0x0000 // jne LBB11_8, $384(%rip) + LONG $0xe0538d4c // leaq $-32(%rbx), %r10 + LONG $0xe0478d48 // leaq $-32(%rdi), %rax + LONG $0x20c08349 // addq $32, %r8 + LONG $0x40fb8348 // cmpq $64, %rbx + WORD $0x9d0f; BYTE $0xc1 // setge %cl + LONG $0x00108c0f; WORD $0x0000 // jl LBB11_11, $16(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + LONG $0x3fff8348 // cmpq $63, %rdi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xffa78f0f; WORD $0xffff // jg LBB11_7, $-89(%rip) + +LBB11_11: + LONG $0x03248d4f // leaq (%r11,%r8), %r12 + WORD $0x014d; BYTE $0xf8 // addq %r15, %r8 + +LBB11_12: + WORD $0xc984 // testb %cl, %cl + LONG $0x0078840f; WORD $0x0000 // je LBB11_38, $120(%rip) + LONG $0x6f7ec1c4; WORD $0x2404 // vmovdqu (%r12), %ymm0 + LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 + LONG $0xd474fdc5 // vpcmpeqb %ymm4, %ymm0, %ymm2 + LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 + LONG $0xc5dbfdc5 // vpand %ymm5, %ymm0, %ymm0 + LONG $0xc674fdc5 // vpcmpeqb %ymm6, %ymm0, %ymm0 + LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 + LONG $0xc8d7fdc5 // vpmovmskb %ymm0, %ecx + QUAD $0x000100000000ba48; WORD $0x0000 // movabsq $4294967296, %rdx + WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx + LONG $0xd1bc0f4c // bsfq %rcx, %r10 + LONG $0x243c8b49 // movq (%r12), %rdi + LONG $0x244c8b49; BYTE $0x08 // movq $8(%r12), %rcx + WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 + LONG $0x01188e0f; WORD $0x0000 // jle LBB11_14, $280(%rip) + LONG $0x10f88348 // cmpq $16, %rax + LONG $0x015b820f; WORD $0x0000 // jb LBB11_27, $347(%rip) + WORD $0x8949; BYTE $0x38 // movq %rdi, (%r8) + LONG $0x08488949 // movq %rcx, $8(%r8) + LONG $0x24548d4d; BYTE $0x10 // leaq $16(%r12), %r10 + LONG $0x10c08349 // addq $16, %r8 + LONG $0xf0708d4c // leaq $-16(%rax), %r14 + LONG $0x08fe8349 // cmpq $8, %r14 + LONG $0x014d830f; WORD $0x0000 // jae LBB11_30, $333(%rip) + LONG $0x00015ae9; BYTE $0x00 // jmp LBB11_31, $346(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB11_38: + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x10fa8349 // cmpq $16, %r10 + WORD $0x9d0f; BYTE $0xc1 // setge %cl + LONG $0x01828c0f; WORD $0x0000 // jl LBB11_39, $386(%rip) + LONG $0x10f88348 // cmpq $16, %rax + QUAD $0xfffffe143d6ff9c5 // vmovdqa $-492(%rip), %xmm7 /* LCPI11_4(%rip) */ + QUAD $0xfffffe1c056f79c5 // vmovdqa $-484(%rip), %xmm8 /* LCPI11_5(%rip) */ + QUAD $0xfffffe240d6f79c5 // vmovdqa $-476(%rip), %xmm9 /* LCPI11_6(%rip) */ + QUAD $0xfffffe2c156f79c5 // vmovdqa $-468(%rip), %xmm10 /* LCPI11_7(%rip) */ + LONG $0x02078c0f; WORD $0x0000 // jl LBB11_41, $519(%rip) + WORD $0x894c; BYTE $0xdf // movq %r11, %rdi + WORD $0x294c; BYTE $0xe7 // subq %r12, %rdi + QUAD $0xfffffd681d6ffdc5 // vmovdqa $-664(%rip), %ymm3 /* LCPI11_0(%rip) */ + QUAD $0xfffffd80256ffdc5 // vmovdqa $-640(%rip), %ymm4 /* LCPI11_1(%rip) */ + QUAD $0xfffffd982d6ffdc5 // vmovdqa $-616(%rip), %ymm5 /* LCPI11_2(%rip) */ + QUAD $0xfffffdb0356ffdc5 // vmovdqa $-592(%rip), %ymm6 /* LCPI11_3(%rip) */ + + // .p2align 4, 0x90 +LBB11_43: + LONG $0x6f7ac1c4; WORD $0x2404 // vmovdqu (%r12), %xmm0 + LONG $0xcf74f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm1 + LONG $0xd074b9c5 // vpcmpeqb %xmm0, %xmm8, %xmm2 + LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 + LONG $0xd0dbb1c5 // vpand %xmm0, %xmm9, %xmm2 + LONG $0xd274a9c5 // vpcmpeqb %xmm2, %xmm10, %xmm2 + LONG $0xcaebf1c5 // vpor %xmm2, %xmm1, %xmm1 + LONG $0x7f7ac1c4; BYTE $0x00 // vmovdqu %xmm0, (%r8) + LONG $0xc9d7f9c5 // vpmovmskb %xmm1, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0083850f; WORD $0x0000 // jne LBB11_44, $131(%rip) + LONG $0x10c48349 // addq $16, %r12 + LONG $0x10c08349 // addq $16, %r8 + LONG $0xf0728d4d // leaq $-16(%r10), %r14 + LONG $0xf0688d4c // leaq $-16(%rax), %r13 + LONG $0x20fa8349 // cmpq $32, %r10 + WORD $0x9d0f; BYTE $0xc1 // setge %cl + LONG $0x012c8c0f; WORD $0x0000 // jl LBB11_47, $300(%rip) + LONG $0xf0c78348 // addq $-16, %rdi + WORD $0x894d; BYTE $0xf2 // movq %r14, %r10 + LONG $0x1ff88348 // cmpq $31, %rax + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + LONG $0xffa08f0f; WORD $0xffff // jg LBB11_43, $-96(%rip) + LONG $0x000113e9; BYTE $0x00 // jmp LBB11_47, $275(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_8: + LONG $0xe0bc0f44 // bsfl %eax, %r12d + WORD $0x014d; BYTE $0xc4 // addq %r8, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0460890f; WORD $0x0000 // jns LBB11_84, $1120(%rip) + LONG $0x00057ae9; BYTE $0x00 // jmp LBB11_83, $1402(%rip) + +LBB11_14: + LONG $0x10fa8341 // cmpl $16, %r10d + LONG $0x0223820f; WORD $0x0000 // jb LBB11_15, $547(%rip) + WORD $0x8949; BYTE $0x38 // movq %rdi, (%r8) + LONG $0x08488949 // movq %rcx, $8(%r8) + LONG $0x24748d4d; BYTE $0x10 // leaq $16(%r12), %r14 + LONG $0x10c08349 // addq $16, %r8 + LONG $0xf0428d49 // leaq $-16(%r10), %rax + LONG $0x08f88348 // cmpq $8, %rax + LONG $0x0215830f; WORD $0x0000 // jae LBB11_18, $533(%rip) + LONG $0x000222e9; BYTE $0x00 // jmp LBB11_19, $546(%rip) + +LBB11_44: + LONG $0xc1bc0f66 // bsfw %cx, %ax + LONG $0xe0b70f44 // movzwl %ax, %r12d + WORD $0x2949; BYTE $0xfc // subq %rdi, %r12 + LONG $0xdc2d8d4c; WORD $0x00e8; BYTE $0x00 // leaq $59612(%rip), %r13 /* __HtmlQuoteTab(%rip) */ + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0413890f; WORD $0x0000 // jns LBB11_84, $1043(%rip) + LONG $0x00052de9; BYTE $0x00 // jmp LBB11_83, $1325(%rip) + +LBB11_27: + WORD $0x894d; BYTE $0xe2 // movq %r12, %r10 + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0x08fe8349 // cmpq $8, %r14 + LONG $0x0012820f; WORD $0x0000 // jb LBB11_31, $18(%rip) + +LBB11_30: + WORD $0x8b49; BYTE $0x0a // movq (%r10), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x08c28349 // addq $8, %r10 + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf8c68349 // addq $-8, %r14 + +LBB11_31: + LONG $0x04fe8349 // cmpq $4, %r14 + LONG $0x020e8d0f; WORD $0x0000 // jge LBB11_32, $526(%rip) + LONG $0x02fe8349 // cmpq $2, %r14 + LONG $0x0220830f; WORD $0x0000 // jae LBB11_34, $544(%rip) + +LBB11_35: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0007840f; WORD $0x0000 // je LBB11_37, $7(%rip) + +LBB11_36: + LONG $0x0ab60f41 // movzbl (%r10), %ecx + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + +LBB11_37: + WORD $0x014c; BYTE $0xe0 // addq %r12, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xd8 // addq %r11, %rax + WORD $0x8949; BYTE $0xc4 // movq %rax, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x03b3890f; WORD $0x0000 // jns LBB11_84, $947(%rip) + LONG $0x0004cde9; BYTE $0x00 // jmp LBB11_83, $1229(%rip) + +LBB11_39: + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x894d; BYTE $0xd6 // movq %r10, %r14 + QUAD $0xfffffc101d6ffdc5 // vmovdqa $-1008(%rip), %ymm3 /* LCPI11_0(%rip) */ + QUAD $0xfffffc28256ffdc5 // vmovdqa $-984(%rip), %ymm4 /* LCPI11_1(%rip) */ + QUAD $0xfffffc402d6ffdc5 // vmovdqa $-960(%rip), %ymm5 /* LCPI11_2(%rip) */ + QUAD $0xfffffc58356ffdc5 // vmovdqa $-936(%rip), %ymm6 /* LCPI11_3(%rip) */ + QUAD $0xfffffc703d6ff9c5 // vmovdqa $-912(%rip), %xmm7 /* LCPI11_4(%rip) */ + QUAD $0xfffffc78056f79c5 // vmovdqa $-904(%rip), %xmm8 /* LCPI11_5(%rip) */ + QUAD $0xfffffc800d6f79c5 // vmovdqa $-896(%rip), %xmm9 /* LCPI11_6(%rip) */ + QUAD $0xfffffc88156f79c5 // vmovdqa $-888(%rip), %xmm10 /* LCPI11_7(%rip) */ + +LBB11_47: + WORD $0xc984 // testb %cl, %cl + LONG $0x008f840f; WORD $0x0000 // je LBB11_48, $143(%rip) + +LBB11_58: + LONG $0x6f7ac1c4; WORD $0x2404 // vmovdqu (%r12), %xmm0 + LONG $0xcf74f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm1 + LONG $0xd074b9c5 // vpcmpeqb %xmm0, %xmm8, %xmm2 + LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 + LONG $0xd0dbb1c5 // vpand %xmm0, %xmm9, %xmm2 + LONG $0xd274a9c5 // vpcmpeqb %xmm2, %xmm10, %xmm2 + LONG $0xcaebf1c5 // vpor %xmm2, %xmm1, %xmm1 + LONG $0xc1d7f9c5 // vpmovmskb %xmm1, %eax + LONG $0x0100000d; BYTE $0x00 // orl $65536, %eax + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax + LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0x01d08d0f; WORD $0x0000 // jge LBB11_59, $464(%rip) + LONG $0x08fd8349 // cmpq $8, %r13 + LONG $0x0210820f; WORD $0x0000 // jb LBB11_70, $528(%rip) + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x24448d49; BYTE $0x08 // leaq $8(%r12), %rax + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf87d8d49 // leaq $-8(%r13), %rdi + LONG $0x04ff8348 // cmpq $4, %rdi + LONG $0x02068d0f; WORD $0x0000 // jge LBB11_73, $518(%rip) + LONG $0x000212e9; BYTE $0x00 // jmp LBB11_74, $530(%rip) + +LBB11_41: + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x894d; BYTE $0xd6 // movq %r10, %r14 + QUAD $0xfffffb611d6ffdc5 // vmovdqa $-1183(%rip), %ymm3 /* LCPI11_0(%rip) */ + QUAD $0xfffffb79256ffdc5 // vmovdqa $-1159(%rip), %ymm4 /* LCPI11_1(%rip) */ + QUAD $0xfffffb912d6ffdc5 // vmovdqa $-1135(%rip), %ymm5 /* LCPI11_2(%rip) */ + QUAD $0xfffffba9356ffdc5 // vmovdqa $-1111(%rip), %ymm6 /* LCPI11_3(%rip) */ + WORD $0xc984 // testb %cl, %cl + LONG $0xff71850f; WORD $0xffff // jne LBB11_58, $-143(%rip) + +LBB11_48: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x00768e0f; WORD $0x0000 // jle LBB11_56, $118(%rip) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x006d8e0f; WORD $0x0000 // jle LBB11_56, $109(%rip) + WORD $0xc931 // xorl %ecx, %ecx + WORD $0xc031 // xorl %eax, %eax + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_51: + LONG $0x3cb60f41; BYTE $0x0c // movzbl (%r12,%rcx), %edi + LONG $0x3eff8348 // cmpq $62, %rdi + LONG $0x0014870f; WORD $0x0000 // ja LBB11_52, $20(%rip) + QUAD $0x004000000000ba48; WORD $0x5000 // movabsq $5764607797912141824, %rdx + LONG $0xfaa30f48 // btq %rdi, %rdx + LONG $0x0164820f; WORD $0x0000 // jb LBB11_80, $356(%rip) + +LBB11_52: + LONG $0x00e2ff81; WORD $0x0000 // cmpl $226, %edi + LONG $0x0158840f; WORD $0x0000 // je LBB11_80, $344(%rip) + LONG $0x061c8d49 // leaq (%r14,%rax), %rbx + LONG $0x083c8841 // movb %dil, (%r8,%rcx) + LONG $0xff788d48 // leaq $-1(%rax), %rdi + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x00138c0f; WORD $0x0000 // jl LBB11_55, $19(%rip) + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + WORD $0xff48; BYTE $0xc1 // incq %rcx + LONG $0x01f88348 // cmpq $1, %rax + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0xffa88f0f; WORD $0xffff // jg LBB11_51, $-88(%rip) + +LBB11_55: + WORD $0x2949; BYTE $0xfc // subq %rdi, %r12 + WORD $0x0149; BYTE $0xfe // addq %rdi, %r14 + +LBB11_56: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x082d8d4c; WORD $0x00e7; BYTE $0x00 // leaq $59144(%rip), %r13 /* __HtmlQuoteTab(%rip) */ + LONG $0x0229840f; WORD $0x0000 // je LBB11_57, $553(%rip) + WORD $0xf749; BYTE $0xd4 // notq %r12 + WORD $0x014d; BYTE $0xdc // addq %r11, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0233890f; WORD $0x0000 // jns LBB11_84, $563(%rip) + LONG $0x00034de9; BYTE $0x00 // jmp LBB11_83, $845(%rip) + +LBB11_15: + WORD $0x894d; BYTE $0xe6 // movq %r12, %r14 + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x08f88348 // cmpq $8, %rax + LONG $0x0012820f; WORD $0x0000 // jb LBB11_19, $18(%rip) + +LBB11_18: + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x08c68349 // addq $8, %r14 + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf8c08348 // addq $-8, %rax + +LBB11_19: + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x006c830f; WORD $0x0000 // jae LBB11_20, $108(%rip) + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x007e830f; WORD $0x0000 // jae LBB11_22, $126(%rip) + +LBB11_23: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0007840f; WORD $0x0000 // je LBB11_25, $7(%rip) + +LBB11_24: + LONG $0x06b60f41 // movzbl (%r14), %eax + WORD $0x8841; BYTE $0x00 // movb %al, (%r8) + +LBB11_25: + WORD $0x294d; BYTE $0xdc // subq %r11, %r12 + WORD $0x014d; BYTE $0xd4 // addq %r10, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x01d9890f; WORD $0x0000 // jns LBB11_84, $473(%rip) + LONG $0x0002f3e9; BYTE $0x00 // jmp LBB11_83, $755(%rip) + +LBB11_32: + WORD $0x8b41; BYTE $0x0a // movl (%r10), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c28349 // addq $4, %r10 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc68349 // addq $-4, %r14 + LONG $0x02fe8349 // cmpq $2, %r14 + LONG $0xfde0820f; WORD $0xffff // jb LBB11_35, $-544(%rip) + +LBB11_34: + LONG $0x0ab70f41 // movzwl (%r10), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c28349 // addq $2, %r10 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec68349 // addq $-2, %r14 + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0xfdcc850f; WORD $0xffff // jne LBB11_36, $-564(%rip) + LONG $0xfffdcee9; BYTE $0xff // jmp LBB11_37, $-562(%rip) + +LBB11_20: + WORD $0x8b41; BYTE $0x0e // movl (%r14), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c68349 // addq $4, %r14 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc08348 // addq $-4, %rax + LONG $0x02f88348 // cmpq $2, %rax + LONG $0xff82820f; WORD $0xffff // jb LBB11_23, $-126(%rip) + +LBB11_22: + LONG $0x0eb70f41 // movzwl (%r14), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c68349 // addq $2, %r14 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec08348 // addq $-2, %rax + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xff6e850f; WORD $0xffff // jne LBB11_24, $-146(%rip) + LONG $0xffff70e9; BYTE $0xff // jmp LBB11_25, $-144(%rip) + +LBB11_59: + WORD $0xf883; BYTE $0x08 // cmpl $8, %eax + LONG $0x009c820f; WORD $0x0000 // jb LBB11_60, $156(%rip) + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x24548d4d; BYTE $0x08 // leaq $8(%r12), %r10 + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf8788d48 // leaq $-8(%rax), %rdi + LONG $0xf82d8d4c; WORD $0x00e5; BYTE $0x00 // leaq $58872(%rip), %r13 /* __HtmlQuoteTab(%rip) */ + LONG $0x04ff8348 // cmpq $4, %rdi + LONG $0x0092830f; WORD $0x0000 // jae LBB11_63, $146(%rip) + LONG $0x00009fe9; BYTE $0x00 // jmp LBB11_64, $159(%rip) + +LBB11_80: + WORD $0x294d; BYTE $0xdc // subq %r11, %r12 + WORD $0x2949; BYTE $0xc4 // subq %rax, %r12 + LONG $0xdc2d8d4c; WORD $0x00e5; BYTE $0x00 // leaq $58844(%rip), %r13 /* __HtmlQuoteTab(%rip) */ + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0113890f; WORD $0x0000 // jns LBB11_84, $275(%rip) + LONG $0x00022de9; BYTE $0x00 // jmp LBB11_83, $557(%rip) + +LBB11_70: + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + LONG $0x04ff8348 // cmpq $4, %rdi + LONG $0x00118c0f; WORD $0x0000 // jl LBB11_74, $17(%rip) + +LBB11_73: + WORD $0x088b // movl (%rax), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c08348 // addq $4, %rax + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc78348 // addq $-4, %rdi + +LBB11_74: + LONG $0x02ff8348 // cmpq $2, %rdi + LONG $0x0087830f; WORD $0x0000 // jae LBB11_75, $135(%rip) + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0006840f; WORD $0x0000 // je LBB11_78, $6(%rip) + +LBB11_77: + WORD $0xb60f; BYTE $0x00 // movzbl (%rax), %eax + WORD $0x8841; BYTE $0x00 // movb %al, (%r8) + +LBB11_78: + WORD $0x014d; BYTE $0xe5 // addq %r12, %r13 + WORD $0xf749; BYTE $0xd5 // notq %r13 + WORD $0x014d; BYTE $0xdd // addq %r11, %r13 + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + LONG $0x812d8d4c; WORD $0x00e5; BYTE $0x00 // leaq $58753(%rip), %r13 /* __HtmlQuoteTab(%rip) */ + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x00b8890f; WORD $0x0000 // jns LBB11_84, $184(%rip) + LONG $0x0001d2e9; BYTE $0x00 // jmp LBB11_83, $466(%rip) + +LBB11_60: + WORD $0x894d; BYTE $0xe2 // movq %r12, %r10 + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0x662d8d4c; WORD $0x00e5; BYTE $0x00 // leaq $58726(%rip), %r13 /* __HtmlQuoteTab(%rip) */ + LONG $0x04ff8348 // cmpq $4, %rdi + LONG $0x0012820f; WORD $0x0000 // jb LBB11_64, $18(%rip) + +LBB11_63: + WORD $0x8b41; BYTE $0x0a // movl (%r10), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c28349 // addq $4, %r10 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc78348 // addq $-4, %rdi + +LBB11_64: + LONG $0x02ff8348 // cmpq $2, %rdi + LONG $0x0045830f; WORD $0x0000 // jae LBB11_65, $69(%rip) + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0007840f; WORD $0x0000 // je LBB11_68, $7(%rip) + +LBB11_67: + LONG $0x0ab60f41 // movzbl (%r10), %ecx + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + +LBB11_68: + WORD $0x294d; BYTE $0xdc // subq %r11, %r12 + WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0061890f; WORD $0x0000 // jns LBB11_84, $97(%rip) + LONG $0x00017be9; BYTE $0x00 // jmp LBB11_83, $379(%rip) + +LBB11_75: + WORD $0xb70f; BYTE $0x08 // movzwl (%rax), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c08348 // addq $2, %rax + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec78348 // addq $-2, %rdi + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xff66850f; WORD $0xffff // jne LBB11_77, $-154(%rip) + LONG $0xffff67e9; BYTE $0xff // jmp LBB11_78, $-153(%rip) + +LBB11_65: + LONG $0x0ab70f41 // movzwl (%r10), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c28349 // addq $2, %r10 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec78348 // addq $-2, %rdi + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xffa7850f; WORD $0xffff // jne LBB11_67, $-89(%rip) + LONG $0xffffa9e9; BYTE $0xff // jmp LBB11_68, $-87(%rip) + +LBB11_57: + WORD $0x294d; BYTE $0xdc // subq %r11, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x012c880f; WORD $0x0000 // js LBB11_83, $300(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_84: + WORD $0x014d; BYTE $0xe3 // addq %r12, %r11 + WORD $0x014d; BYTE $0xe7 // addq %r12, %r15 + WORD $0x294c; BYTE $0xe6 // subq %r12, %rsi + LONG $0x01338e0f; WORD $0x0000 // jle LBB11_85, $307(%rip) + WORD $0x294d; BYTE $0xe1 // subq %r12, %r9 + LONG $0x0bb60f41 // movzbl (%r11), %ecx + WORD $0xf980; BYTE $0xe2 // cmpb $-30, %cl + LONG $0x00b2840f; WORD $0x0000 // je LBB11_88, $178(%rip) + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + +LBB11_92: + WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x293c8b4a // movq (%rcx,%r13), %rdi + WORD $0x6348; BYTE $0xdf // movslq %edi, %rbx + WORD $0x2949; BYTE $0xd9 // subq %rbx, %r9 + LONG $0x01208c0f; WORD $0x0000 // jl LBB11_93, $288(%rip) + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx + LONG $0x08c18348 // addq $8, %rcx + QUAD $0x000300000001ba48; WORD $0x0000 // movabsq $12884901889, %rdx + WORD $0x3948; BYTE $0xd7 // cmpq %rdx, %rdi + LONG $0x00298c0f; WORD $0x0000 // jl LBB11_97, $41(%rip) + WORD $0x398b // movl (%rcx), %edi + WORD $0x8941; BYTE $0x3f // movl %edi, (%r15) + LONG $0x04c18348 // addq $4, %rcx + LONG $0x04578d4d // leaq $4(%r15), %r10 + LONG $0xfc7b8d48 // leaq $-4(%rbx), %rdi + LONG $0x02ff8348 // cmpq $2, %rdi + LONG $0x001e830f; WORD $0x0000 // jae LBB11_100, $30(%rip) + LONG $0x00002ce9; BYTE $0x00 // jmp LBB11_101, $44(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_97: + WORD $0x894d; BYTE $0xfa // movq %r15, %r10 + WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi + LONG $0x02ff8348 // cmpq $2, %rdi + LONG $0x0013820f; WORD $0x0000 // jb LBB11_101, $19(%rip) + +LBB11_100: + WORD $0xb70f; BYTE $0x11 // movzwl (%rcx), %edx + LONG $0x12894166 // movw %dx, (%r10) + LONG $0x02c18348 // addq $2, %rcx + LONG $0x02c28349 // addq $2, %r10 + LONG $0xfec78348 // addq $-2, %rdi + +LBB11_101: + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0006840f; WORD $0x0000 // je LBB11_103, $6(%rip) + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + WORD $0x8841; BYTE $0x0a // movb %cl, (%r10) + +LBB11_103: + WORD $0x0149; BYTE $0xdf // addq %rbx, %r15 + +LBB11_104: + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + LONG $0x01fe8348 // cmpq $1, %rsi + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0xf8d4870f; WORD $0xffff // ja LBB11_2, $-1836(%rip) + LONG $0x000074e9; BYTE $0x00 // jmp LBB11_105, $116(%rip) + +LBB11_88: + LONG $0x03fe8348 // cmpq $3, %rsi + LONG $0x0029820f; WORD $0x0000 // jb LBB11_94, $41(%rip) + LONG $0x017b8041; BYTE $0x80 // cmpb $-128, $1(%r11) + LONG $0x001e850f; WORD $0x0000 // jne LBB11_94, $30(%rip) + LONG $0x4bb60f41; BYTE $0x02 // movzbl $2(%r11), %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xfe24 // andb $-2, %al + WORD $0xa83c // cmpb $-88, %al + LONG $0x000d850f; WORD $0x0000 // jne LBB11_94, $13(%rip) + LONG $0x02438d49 // leaq $2(%r11), %rax + LONG $0xfec68348 // addq $-2, %rsi + LONG $0xffff1ee9; BYTE $0xff // jmp LBB11_92, $-226(%rip) + +LBB11_94: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x00578e0f; WORD $0x0000 // jle LBB11_3, $87(%rip) + LONG $0xe207c641 // movb $-30, (%r15) + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xff49; BYTE $0xc9 // decq %r9 + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + LONG $0xffff96e9; BYTE $0xff // jmp LBB11_104, $-106(%rip) + +LBB11_83: + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x014c; BYTE $0xe1 // addq %r12, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x014c; BYTE $0xf9 // addq %r15, %rcx + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x294c; BYTE $0xd8 // subq %r11, %rax + WORD $0x014c; BYTE $0xe0 // addq %r12, %rax + LONG $0x00002ce9; BYTE $0x00 // jmp LBB11_106, $44(%rip) + +LBB11_85: + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + +LBB11_105: + LONG $0xc87d2b4c // subq $-56(%rbp), %r15 + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x894c; BYTE $0x39 // movq %r15, (%rcx) + LONG $0xd0452b48 // subq $-48(%rbp), %rax + LONG $0x000015e9; BYTE $0x00 // jmp LBB11_106, $21(%rip) + +LBB11_93: + LONG $0xc87d2b4c // subq $-56(%rbp), %r15 + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + +LBB11_3: + WORD $0xf749; BYTE $0xd3 // notq %r11 + LONG $0xd05d034c // addq $-48(%rbp), %r11 + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + +LBB11_106: + LONG $0x18c48348 // addq $24, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + + // .p2align 4, 0x90 +_atof_eisel_lemire64: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0xfea4868d; WORD $0xffff // leal $-348(%rsi), %eax + LONG $0xfffd483d; BYTE $0xff // cmpl $-696, %eax + LONG $0x0122820f; WORD $0x0000 // jb LBB12_1, $290(%rip) + WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 + WORD $0x8941; BYTE $0xd1 // movl %edx, %r9d + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x000d840f; WORD $0x0000 // je LBB12_4, $13(%rip) + LONG $0xd7bd0f4c // bsrq %rdi, %r10 + LONG $0x3ff28349 // xorq $63, %r10 + LONG $0x000006e9; BYTE $0x00 // jmp LBB12_5, $6(%rip) + +LBB12_4: + LONG $0x0040ba41; WORD $0x0000 // movl $64, %r10d + +LBB12_5: + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xd348; BYTE $0xe7 // shlq %cl, %rdi + LONG $0x015c8e8d; WORD $0x0000 // leal $348(%rsi), %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x3b258d4c; WORD $0x006d; BYTE $0x00 // leaq $27963(%rip), %r12 /* _POW10_M128_TAB(%rip) */ + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x2164f74a; BYTE $0x08 // mulq $8(%rcx,%r12) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x8949; BYTE $0xd3 // movq %rdx, %r11 + WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx + LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx + LONG $0xfffb8148; WORD $0x0001; BYTE $0x00 // cmpq $511, %rbx + LONG $0x0050850f; WORD $0x0000 // jne LBB12_11, $80(%rip) + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + WORD $0xf749; BYTE $0xd6 // notq %r14 + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0x394d; BYTE $0xf7 // cmpq %r14, %r15 + LONG $0x0041860f; WORD $0x0000 // jbe LBB12_13, $65(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x2124f74a // mulq (%rcx,%r12) + WORD $0x014c; BYTE $0xfa // addq %r15, %rdx + LONG $0x00d38349 // adcq $0, %r11 + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0x37e1c148 // shlq $55, %rcx + LONG $0x0013850f; WORD $0x0000 // jne LBB12_12, $19(%rip) + LONG $0xfffa8348 // cmpq $-1, %rdx + LONG $0x0009850f; WORD $0x0000 // jne LBB12_12, $9(%rip) + WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax + LONG $0x0083870f; WORD $0x0000 // ja LBB12_1, $131(%rip) + +LBB12_12: + WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx + LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx + LONG $0x000003e9; BYTE $0x00 // jmp LBB12_13, $3(%rip) + +LBB12_11: + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + +LBB12_13: + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + LONG $0x3fe8c148 // shrq $63, %rax + WORD $0x488d; BYTE $0x09 // leal $9(%rax), %ecx + WORD $0xd349; BYTE $0xeb // shrq %cl, %r11 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0018850f; WORD $0x0000 // jne LBB12_17, $24(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x000f850f; WORD $0x0000 // jne LBB12_17, $15(%rip) + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + WORD $0xe183; BYTE $0x03 // andl $3, %ecx + WORD $0xf983; BYTE $0x01 // cmpl $1, %ecx + LONG $0x0044840f; WORD $0x0000 // je LBB12_1, $68(%rip) + +LBB12_17: + LONG $0x526ace69; WORD $0x0003 // imull $217706, %esi, %ecx + WORD $0xf9c1; BYTE $0x10 // sarl $16, %ecx + LONG $0x043fc181; WORD $0x0000 // addl $1087, %ecx + WORD $0x6348; BYTE $0xf1 // movslq %ecx, %rsi + WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi + WORD $0x8944; BYTE $0xda // movl %r11d, %edx + WORD $0xe283; BYTE $0x01 // andl $1, %edx + WORD $0x014c; BYTE $0xda // addq %r11, %rdx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x36e9c148 // shrq $54, %rcx + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0x01f98348 // cmpq $1, %rcx + LONG $0x00d88348 // sbbq $0, %rax + LONG $0x01b08d48; WORD $0xfff8; BYTE $0xff // leaq $-2047(%rax), %rsi + LONG $0x02fe8148; WORD $0xfff8; BYTE $0xff // cmpq $-2046, %rsi + LONG $0x000b830f; WORD $0x0000 // jae LBB12_19, $11(%rip) + +LBB12_1: + WORD $0xc031 // xorl %eax, %eax + +LBB12_20: + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB12_19: + LONG $0x01f98348 // cmpq $1, %rcx + WORD $0x02b1 // movb $2, %cl + WORD $0xd980; BYTE $0x00 // sbbb $0, %cl + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + LONG $0x34e0c148 // shlq $52, %rax + QUAD $0xffffffffffffb948; WORD $0x000f // movabsq $4503599627370495, %rcx + WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xfff98341 // cmpl $-1, %r9d + LONG $0xc1450f48 // cmovneq %rcx, %rax + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + WORD $0x01b0 // movb $1, %al + LONG $0xffffb8e9; BYTE $0xff // jmp LBB12_20, $-72(%rip) + QUAD $0x0000000000000000 // .p2align 5, 0x00 + +LCPI13_0: + QUAD $0x0000000000000000 // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000001 // .quad 1 + + // .p2align 3, 0x00 +LCPI13_1: + QUAD $0x0000000000000001 // .quad 1 + +LCPI13_2: + QUAD $0x0000000000002710 // .quad 10000 + +LCPI13_3: + QUAD $0x000000000000000a // .quad 10 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +_decimal_to_f64: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 + LONG $0x00107f83 // cmpl $0, $16(%rdi) + LONG $0x0021840f; WORD $0x0000 // je LBB13_3, $33(%rip) + LONG $0x14478b41 // movl $20(%r15), %eax + LONG $0x0001363d; BYTE $0x00 // cmpl $310, %eax + LONG $0x001d8e0f; WORD $0x0000 // jle LBB13_4, $29(%rip) + +LBB13_2: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 + LONG $0x000566e9; BYTE $0x00 // jmp LBB13_74, $1382(%rip) + +LBB13_3: + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x00055be9; BYTE $0x00 // jmp LBB13_74, $1371(%rip) + +LBB13_4: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xfffeb63d; BYTE $0xff // cmpl $-330, %eax + LONG $0x00088d0f; WORD $0x0000 // jge LBB13_6, $8(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x000545e9; BYTE $0x00 // jmp LBB13_74, $1349(%rip) + +LBB13_6: + WORD $0xc085 // testl %eax, %eax + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x00aa8e0f; WORD $0x0000 // jle LBB13_17, $170(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xd0358d4c; WORD $0x0096; BYTE $0x00 // leaq $38608(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x000039e9; BYTE $0x00 // jmp LBB13_11, $57(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_8: + LONG $0xffffe5be; BYTE $0xff // movl $-27, %esi + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x000a840f; WORD $0x0000 // je LBB13_10, $10(%rip) + +LBB13_9: + WORD $0xdef7 // negl %esi + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x006301e8; BYTE $0x00 // callq _right_shift, $25345(%rip) + +LBB13_10: + WORD $0x0141; BYTE $0xdc // addl %ebx, %r12d + LONG $0x14478b41 // movl $20(%r15), %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x00628e0f; WORD $0x0000 // jle LBB13_17, $98(%rip) + +LBB13_11: + WORD $0xf883; BYTE $0x08 // cmpl $8, %eax + LONG $0xffc9870f; WORD $0xffff // ja LBB13_8, $-55(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0x861c8b41 // movl (%r14,%rax,4), %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xffd7840f; WORD $0xffff // je LBB13_10, $-41(%rip) + WORD $0xde89 // movl %ebx, %esi + WORD $0xdef7 // negl %esi + WORD $0xfe83; BYTE $0xc3 // cmpl $-61, %esi + LONG $0xffc0870f; WORD $0xffff // ja LBB13_9, $-64(%rip) + WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB13_15: + WORD $0x8941; BYTE $0xf6 // movl %esi, %r14d + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi + LONG $0x0062b0e8; BYTE $0x00 // callq _right_shift, $25264(%rip) + LONG $0x3c768d41 // leal $60(%r14), %esi + LONG $0x88fe8341 // cmpl $-120, %r14d + LONG $0xffe2820f; WORD $0xffff // jb LBB13_15, $-30(%rip) + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 + LONG $0xffff85e9; BYTE $0xff // jmp LBB13_9, $-123(%rip) + +LBB13_17: + LONG $0x29358d4c; WORD $0x0096; BYTE $0x00 // leaq $38441(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x000025e9; BYTE $0x00 // jmp LBB13_19, $37(%rip) + +LBB13_23: + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x0012840f; WORD $0x0000 // je LBB13_18, $18(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB13_25: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0xde89 // movl %ebx, %esi + LONG $0x006076e8; BYTE $0x00 // callq _left_shift, $24694(%rip) + LONG $0x14478b41 // movl $20(%r15), %eax + +LBB13_18: + WORD $0x2941; BYTE $0xdc // subl %ebx, %r12d + +LBB13_19: + WORD $0xc085 // testl %eax, %eax + LONG $0x0017880f; WORD $0x0000 // js LBB13_22, $23(%rip) + LONG $0x0032850f; WORD $0x0000 // jne LBB13_26, $50(%rip) + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + WORD $0x3980; BYTE $0x35 // cmpb $53, (%rcx) + LONG $0x000e8c0f; WORD $0x0000 // jl LBB13_24, $14(%rip) + LONG $0x000021e9; BYTE $0x00 // jmp LBB13_26, $33(%rip) + + // .p2align 4, 0x90 +LBB13_22: + WORD $0xf883; BYTE $0xf8 // cmpl $-8, %eax + LONG $0xffb3820f; WORD $0xffff // jb LBB13_23, $-77(%rip) + +LBB13_24: + WORD $0xc189 // movl %eax, %ecx + WORD $0xd9f7 // negl %ecx + LONG $0x8e1c8b41 // movl (%r14,%rcx,4), %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xffb4850f; WORD $0xffff // jne LBB13_25, $-76(%rip) + LONG $0xffffbde9; BYTE $0xff // jmp LBB13_18, $-67(%rip) + +LBB13_26: + LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff // cmpl $-1022, %r12d + LONG $0x00568f0f; WORD $0x0000 // jg LBB13_32, $86(%rip) + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x0075840f; WORD $0x0000 // je LBB13_35, $117(%rip) + LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff // cmpl $-1082, %r12d + LONG $0x0073870f; WORD $0x0000 // ja LBB13_36, $115(%rip) + LONG $0xc1c48141; WORD $0x0003; BYTE $0x00 // addl $961, %r12d + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_30: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi + LONG $0x0061d3e8; BYTE $0x00 // callq _right_shift, $25043(%rip) + LONG $0x3cc48341 // addl $60, %r12d + LONG $0x88fc8341 // cmpl $-120, %r12d + LONG $0xffe5820f; WORD $0xffff // jb LBB13_30, $-27(%rip) + LONG $0x3cc48341 // addl $60, %r12d + LONG $0x000040e9; BYTE $0x00 // jmp LBB13_37, $64(%rip) + +LBB13_32: + LONG $0x00fc8141; WORD $0x0004; BYTE $0x00 // cmpl $1024, %r12d + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 + LONG $0x00088e0f; WORD $0x0000 // jle LBB13_34, $8(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x000398e9; BYTE $0x00 // jmp LBB13_74, $920(%rip) + +LBB13_34: + WORD $0xff41; BYTE $0xcc // decl %r12d + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + LONG $0x000026e9; BYTE $0x00 // jmp LBB13_38, $38(%rip) + +LBB13_35: + LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d + LONG $0x000033e9; BYTE $0x00 // jmp LBB13_40, $51(%rip) + +LBB13_36: + LONG $0xfdc48141; WORD $0x0003; BYTE $0x00 // addl $1021, %r12d + +LBB13_37: + WORD $0xf741; BYTE $0xdc // negl %r12d + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x8944; BYTE $0xe6 // movl %r12d, %esi + LONG $0x00616ee8; BYTE $0x00 // callq _right_shift, $24942(%rip) + LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d + +LBB13_38: + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x000d840f; WORD $0x0000 // je LBB13_40, $13(%rip) + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x000035be; BYTE $0x00 // movl $53, %esi + LONG $0x005f60e8; BYTE $0x00 // callq _left_shift, $24416(%rip) + +LBB13_40: + LONG $0x14478b41 // movl $20(%r15), %eax + LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 + WORD $0xf883; BYTE $0x14 // cmpl $20, %eax + LONG $0x031c8f0f; WORD $0x0000 // jg LBB13_73, $796(%rip) + WORD $0xc085 // testl %eax, %eax + LONG $0x00558e0f; WORD $0x0000 // jle LBB13_46, $85(%rip) + LONG $0x10578b41 // movl $16(%r15), %edx + WORD $0xf631 // xorl %esi, %esi + WORD $0xd285 // testl %edx, %edx + WORD $0x4e0f; BYTE $0xd6 // cmovlel %esi, %edx + LONG $0xff488d4c // leaq $-1(%rax), %r9 + WORD $0x3949; BYTE $0xd1 // cmpq %rdx, %r9 + LONG $0xca430f4c // cmovaeq %rdx, %r9 + LONG $0x01418d4d // leaq $1(%r9), %r8 + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_43: + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x002e840f; WORD $0x0000 // je LBB13_47, $46(%rip) + LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x0cbe0f48; BYTE $0x31 // movsbq (%rcx,%rsi), %rcx + LONG $0x79248d4c // leaq (%rcx,%rdi,2), %r12 + LONG $0xd0c48349 // addq $-48, %r12 + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffd7850f; WORD $0xffff // jne LBB13_43, $-41(%rip) + WORD $0x894d; BYTE $0xc1 // movq %r8, %r9 + LONG $0x000006e9; BYTE $0x00 // jmp LBB13_47, $6(%rip) + +LBB13_46: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + +LBB13_47: + WORD $0x3944; BYTE $0xc8 // cmpl %r9d, %eax + LONG $0x022f8e0f; WORD $0x0000 // jle LBB13_60, $559(%rip) + WORD $0xc289 // movl %eax, %edx + WORD $0x2944; BYTE $0xca // subl %r9d, %edx + WORD $0xfa83; BYTE $0x10 // cmpl $16, %edx + LONG $0x020d820f; WORD $0x0000 // jb LBB13_58, $525(%rip) + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + LONG $0x6ef9c1c4; BYTE $0xc4 // vmovq %r12, %xmm0 + QUAD $0xfffcc005027de3c4; WORD $0xfcff // vpblendd $252, $-832(%rip), %ymm0, %ymm0 /* LCPI13_0(%rip) */ + LONG $0xf0e08341 // andl $-16, %r8d + LONG $0xf0488d41 // leal $-16(%r8), %ecx + WORD $0xcf89 // movl %ecx, %edi + WORD $0xefc1; BYTE $0x04 // shrl $4, %edi + WORD $0xc7ff // incl %edi + WORD $0xfe89 // movl %edi, %esi + WORD $0xe683; BYTE $0x03 // andl $3, %esi + WORD $0xf983; BYTE $0x30 // cmpl $48, %ecx + LONG $0x0016830f; WORD $0x0000 // jae LBB13_51, $22(%rip) + QUAD $0xfffcba15597de2c4; BYTE $0xff // vpbroadcastq $-838(%rip), %ymm2 /* LCPI13_1(%rip) */ + LONG $0xda6ffdc5 // vmovdqa %ymm2, %ymm3 + LONG $0xca6ffdc5 // vmovdqa %ymm2, %ymm1 + LONG $0x00007ee9; BYTE $0x00 // jmp LBB13_53, $126(%rip) + +LBB13_51: + WORD $0xe783; BYTE $0xfc // andl $-4, %edi + QUAD $0xfffca115597de2c4; BYTE $0xff // vpbroadcastq $-863(%rip), %ymm2 /* LCPI13_1(%rip) */ + QUAD $0xfffca025597de2c4; BYTE $0xff // vpbroadcastq $-864(%rip), %ymm4 /* LCPI13_2(%rip) */ + LONG $0xda6ffdc5 // vmovdqa %ymm2, %ymm3 + LONG $0xca6ffdc5 // vmovdqa %ymm2, %ymm1 + + // .p2align 4, 0x90 +LBB13_52: + LONG $0xecf4fdc5 // vpmuludq %ymm4, %ymm0, %ymm5 + LONG $0xd073fdc5; BYTE $0x20 // vpsrlq $32, %ymm0, %ymm0 + LONG $0xc4f4fdc5 // vpmuludq %ymm4, %ymm0, %ymm0 + LONG $0xf073fdc5; BYTE $0x20 // vpsllq $32, %ymm0, %ymm0 + LONG $0xc0d4d5c5 // vpaddq %ymm0, %ymm5, %ymm0 + LONG $0xecf4edc5 // vpmuludq %ymm4, %ymm2, %ymm5 + LONG $0xd273edc5; BYTE $0x20 // vpsrlq $32, %ymm2, %ymm2 + LONG $0xd4f4edc5 // vpmuludq %ymm4, %ymm2, %ymm2 + LONG $0xf273edc5; BYTE $0x20 // vpsllq $32, %ymm2, %ymm2 + LONG $0xd2d4d5c5 // vpaddq %ymm2, %ymm5, %ymm2 + LONG $0xecf4e5c5 // vpmuludq %ymm4, %ymm3, %ymm5 + LONG $0xd373e5c5; BYTE $0x20 // vpsrlq $32, %ymm3, %ymm3 + LONG $0xdcf4e5c5 // vpmuludq %ymm4, %ymm3, %ymm3 + LONG $0xf373e5c5; BYTE $0x20 // vpsllq $32, %ymm3, %ymm3 + LONG $0xdbd4d5c5 // vpaddq %ymm3, %ymm5, %ymm3 + LONG $0xecf4f5c5 // vpmuludq %ymm4, %ymm1, %ymm5 + LONG $0xd173f5c5; BYTE $0x20 // vpsrlq $32, %ymm1, %ymm1 + LONG $0xccf4f5c5 // vpmuludq %ymm4, %ymm1, %ymm1 + LONG $0xf173f5c5; BYTE $0x20 // vpsllq $32, %ymm1, %ymm1 + LONG $0xc9d4d5c5 // vpaddq %ymm1, %ymm5, %ymm1 + WORD $0xc783; BYTE $0xfc // addl $-4, %edi + LONG $0xff9f850f; WORD $0xffff // jne LBB13_52, $-97(%rip) + +LBB13_53: + WORD $0xf685 // testl %esi, %esi + LONG $0x0077840f; WORD $0x0000 // je LBB13_56, $119(%rip) + QUAD $0xfffc2e25597de2c4; BYTE $0xff // vpbroadcastq $-978(%rip), %ymm4 /* LCPI13_3(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB13_55: + LONG $0xecf4fdc5 // vpmuludq %ymm4, %ymm0, %ymm5 + LONG $0xd073fdc5; BYTE $0x20 // vpsrlq $32, %ymm0, %ymm0 + LONG $0xc4f4fdc5 // vpmuludq %ymm4, %ymm0, %ymm0 + LONG $0xf073fdc5; BYTE $0x20 // vpsllq $32, %ymm0, %ymm0 + LONG $0xc0d4d5c5 // vpaddq %ymm0, %ymm5, %ymm0 + LONG $0xecf4edc5 // vpmuludq %ymm4, %ymm2, %ymm5 + LONG $0xd273edc5; BYTE $0x20 // vpsrlq $32, %ymm2, %ymm2 + LONG $0xd4f4edc5 // vpmuludq %ymm4, %ymm2, %ymm2 + LONG $0xf273edc5; BYTE $0x20 // vpsllq $32, %ymm2, %ymm2 + LONG $0xd2d4d5c5 // vpaddq %ymm2, %ymm5, %ymm2 + LONG $0xecf4e5c5 // vpmuludq %ymm4, %ymm3, %ymm5 + LONG $0xd373e5c5; BYTE $0x20 // vpsrlq $32, %ymm3, %ymm3 + LONG $0xdcf4e5c5 // vpmuludq %ymm4, %ymm3, %ymm3 + LONG $0xf373e5c5; BYTE $0x20 // vpsllq $32, %ymm3, %ymm3 + LONG $0xdbd4d5c5 // vpaddq %ymm3, %ymm5, %ymm3 + LONG $0xecf4f5c5 // vpmuludq %ymm4, %ymm1, %ymm5 + LONG $0xd173f5c5; BYTE $0x20 // vpsrlq $32, %ymm1, %ymm1 + LONG $0xccf4f5c5 // vpmuludq %ymm4, %ymm1, %ymm1 + LONG $0xf173f5c5; BYTE $0x20 // vpsllq $32, %ymm1, %ymm1 + LONG $0xc9d4d5c5 // vpaddq %ymm1, %ymm5, %ymm1 + WORD $0xceff // decl %esi + LONG $0xffa0850f; WORD $0xffff // jne LBB13_55, $-96(%rip) + +LBB13_56: + LONG $0xd273ddc5; BYTE $0x20 // vpsrlq $32, %ymm2, %ymm4 + LONG $0xe0f4ddc5 // vpmuludq %ymm0, %ymm4, %ymm4 + LONG $0xd073d5c5; BYTE $0x20 // vpsrlq $32, %ymm0, %ymm5 + LONG $0xedf4edc5 // vpmuludq %ymm5, %ymm2, %ymm5 + LONG $0xe4d4d5c5 // vpaddq %ymm4, %ymm5, %ymm4 + LONG $0xf473ddc5; BYTE $0x20 // vpsllq $32, %ymm4, %ymm4 + LONG $0xc0f4edc5 // vpmuludq %ymm0, %ymm2, %ymm0 + LONG $0xc4d4fdc5 // vpaddq %ymm4, %ymm0, %ymm0 + LONG $0xd373edc5; BYTE $0x20 // vpsrlq $32, %ymm3, %ymm2 + LONG $0xd0f4edc5 // vpmuludq %ymm0, %ymm2, %ymm2 + LONG $0xd073ddc5; BYTE $0x20 // vpsrlq $32, %ymm0, %ymm4 + LONG $0xe4f4e5c5 // vpmuludq %ymm4, %ymm3, %ymm4 + LONG $0xd2d4ddc5 // vpaddq %ymm2, %ymm4, %ymm2 + LONG $0xf273edc5; BYTE $0x20 // vpsllq $32, %ymm2, %ymm2 + LONG $0xc0f4e5c5 // vpmuludq %ymm0, %ymm3, %ymm0 + LONG $0xc2d4fdc5 // vpaddq %ymm2, %ymm0, %ymm0 + LONG $0xd173edc5; BYTE $0x20 // vpsrlq $32, %ymm1, %ymm2 + LONG $0xd0f4edc5 // vpmuludq %ymm0, %ymm2, %ymm2 + LONG $0xd073e5c5; BYTE $0x20 // vpsrlq $32, %ymm0, %ymm3 + LONG $0xdbf4f5c5 // vpmuludq %ymm3, %ymm1, %ymm3 + LONG $0xd2d4e5c5 // vpaddq %ymm2, %ymm3, %ymm2 + LONG $0xf273edc5; BYTE $0x20 // vpsllq $32, %ymm2, %ymm2 + LONG $0xc0f4f5c5 // vpmuludq %ymm0, %ymm1, %ymm0 + LONG $0xc2d4fdc5 // vpaddq %ymm2, %ymm0, %ymm0 + LONG $0x397de3c4; WORD $0x01c1 // vextracti128 $1, %ymm0, %xmm1 + LONG $0xd073e9c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm2 + LONG $0xd1f4e9c5 // vpmuludq %xmm1, %xmm2, %xmm2 + LONG $0xd173e1c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm3 + LONG $0xdbf4f9c5 // vpmuludq %xmm3, %xmm0, %xmm3 + LONG $0xd2d4e1c5 // vpaddq %xmm2, %xmm3, %xmm2 + LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 + LONG $0xc1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm0 + LONG $0xc2d4f9c5 // vpaddq %xmm2, %xmm0, %xmm0 + LONG $0xc870f9c5; BYTE $0xee // vpshufd $238, %xmm0, %xmm1 + LONG $0xd073e9c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm2 + LONG $0xd1f4e9c5 // vpmuludq %xmm1, %xmm2, %xmm2 + LONG $0xd870f9c5; BYTE $0xff // vpshufd $255, %xmm0, %xmm3 + LONG $0xdbf4f9c5 // vpmuludq %xmm3, %xmm0, %xmm3 + LONG $0xd2d4e1c5 // vpaddq %xmm2, %xmm3, %xmm2 + LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 + LONG $0xc1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm0 + LONG $0xc2d4f9c5 // vpaddq %xmm2, %xmm0, %xmm0 + LONG $0x7ef9c1c4; BYTE $0xc4 // vmovq %xmm0, %r12 + WORD $0x3944; BYTE $0xc2 // cmpl %r8d, %edx + LONG $0x0017840f; WORD $0x0000 // je LBB13_60, $23(%rip) + WORD $0x0145; BYTE $0xc1 // addl %r8d, %r9d + +LBB13_58: + WORD $0xc289 // movl %eax, %edx + WORD $0x2944; BYTE $0xca // subl %r9d, %edx + + // .p2align 4, 0x90 +LBB13_59: + WORD $0x014d; BYTE $0xe4 // addq %r12, %r12 + LONG $0xa4248d4f // leaq (%r12,%r12,4), %r12 + WORD $0xcaff // decl %edx + LONG $0xfff1850f; WORD $0xffff // jne LBB13_59, $-15(%rip) + +LBB13_60: + WORD $0xc085 // testl %eax, %eax + LONG $0x004b880f; WORD $0x0000 // js LBB13_67, $75(%rip) + LONG $0x10578b41 // movl $16(%r15), %edx + WORD $0xc239 // cmpl %eax, %edx + LONG $0x003f8e0f; WORD $0x0000 // jle LBB13_67, $63(%rip) + WORD $0x8b49; BYTE $0x37 // movq (%r15), %rsi + LONG $0x060cb60f // movzbl (%rsi,%rax), %ecx + WORD $0xf980; BYTE $0x35 // cmpb $53, %cl + LONG $0x00b2850f; WORD $0x0000 // jne LBB13_69, $178(%rip) + WORD $0x788d; BYTE $0x01 // leal $1(%rax), %edi + WORD $0xd739 // cmpl %edx, %edi + LONG $0x00a7850f; WORD $0x0000 // jne LBB13_69, $167(%rip) + WORD $0x01b2 // movb $1, %dl + LONG $0x1c7f8341; BYTE $0x00 // cmpl $0, $28(%r15) + LONG $0x0019850f; WORD $0x0000 // jne LBB13_70, $25(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x000e840f; WORD $0x0000 // je LBB13_67, $14(%rip) + WORD $0xc8ff // decl %eax + LONG $0x0614b60f // movzbl (%rsi,%rax), %edx + WORD $0xe280; BYTE $0x01 // andb $1, %dl + LONG $0x000002e9; BYTE $0x00 // jmp LBB13_70, $2(%rip) + +LBB13_67: + WORD $0xd231 // xorl %edx, %edx + +LBB13_70: + WORD $0xb60f; BYTE $0xc2 // movzbl %dl, %eax + WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 + QUAD $0x000000000000b848; WORD $0x0020 // movabsq $9007199254740992, %rax + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0x0013850f; WORD $0x0000 // jne LBB13_73, $19(%rip) + LONG $0xfefe8141; WORD $0x0003; BYTE $0x00 // cmpl $1022, %r14d + LONG $0xfaad8f0f; WORD $0xffff // jg LBB13_2, $-1363(%rip) + WORD $0xff41; BYTE $0xc6 // incl %r14d + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + +LBB13_73: + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + WORD $0x214c; BYTE $0xe8 // andq %r13, %rax + LONG $0xffc68141; WORD $0x0003; BYTE $0x00 // addl $1023, %r14d + LONG $0xffe68141; WORD $0x0007; BYTE $0x00 // andl $2047, %r14d + LONG $0x34e6c149 // shlq $52, %r14 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xf0440f4c // cmoveq %rax, %r14 + +LBB13_74: + WORD $0xff49; BYTE $0xcd // decq %r13 + WORD $0x214d; BYTE $0xe5 // andq %r12, %r13 + WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 + QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax + WORD $0x094c; BYTE $0xe8 // orq %r13, %rax + LONG $0x187f8341; BYTE $0x00 // cmpl $0, $24(%r15) + LONG $0xc5440f49 // cmoveq %r13, %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + WORD $0xc031 // xorl %eax, %eax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB13_69: + WORD $0xf980; BYTE $0x35 // cmpb $53, %cl + WORD $0x9d0f; BYTE $0xc2 // setge %dl + LONG $0xffff74e9; BYTE $0xff // jmp LBB13_70, $-140(%rip) + + // .p2align 4, 0x90 +_atof_native: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x28ec8348 // subq $40, %rsp + QUAD $0x00000000d045c748 // movq $0, $-48(%rbp) + LONG $0xb0558948 // movq %rdx, $-80(%rbp) + LONG $0xb84d8948 // movq %rcx, $-72(%rbp) + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0197840f; WORD $0x0000 // je LBB14_18, $407(%rip) + LONG $0x10f98348 // cmpq $16, %rcx + LONG $0x0008830f; WORD $0x0000 // jae LBB14_3, $8(%rip) + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x000174e9; BYTE $0x00 // jmp LBB14_17, $372(%rip) + +LBB14_3: + LONG $0x80f98148; WORD $0x0000; BYTE $0x00 // cmpq $128, %rcx + LONG $0x0008830f; WORD $0x0000 // jae LBB14_5, $8(%rip) + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x000129e9; BYTE $0x00 // jmp LBB14_14, $297(%rip) + +LBB14_5: + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0x80e28349 // andq $-128, %r10 + LONG $0x80428d49 // leaq $-128(%r10), %rax + WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 + LONG $0x07e9c149 // shrq $7, %r9 + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0x8945; BYTE $0xc8 // movl %r9d, %r8d + LONG $0x03e08341 // andl $3, %r8d + LONG $0x01803d48; WORD $0x0000 // cmpq $384, %rax + LONG $0x0007830f; WORD $0x0000 // jae LBB14_7, $7(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x0000a4e9; BYTE $0x00 // jmp LBB14_9, $164(%rip) + +LBB14_7: + LONG $0xfce18349 // andq $-4, %r9 + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB14_8: + LONG $0x0411fcc5; BYTE $0x1a // vmovups %ymm0, (%rdx,%rbx) + LONG $0x4411fcc5; WORD $0x201a // vmovups %ymm0, $32(%rdx,%rbx) + LONG $0x4411fcc5; WORD $0x401a // vmovups %ymm0, $64(%rdx,%rbx) + LONG $0x4411fcc5; WORD $0x601a // vmovups %ymm0, $96(%rdx,%rbx) + QUAD $0x0000801a8411fcc5; BYTE $0x00 // vmovups %ymm0, $128(%rdx,%rbx) + QUAD $0x0000a01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $160(%rdx,%rbx) + QUAD $0x0000c01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $192(%rdx,%rbx) + QUAD $0x0000e01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $224(%rdx,%rbx) + QUAD $0x0001001a8411fcc5; BYTE $0x00 // vmovups %ymm0, $256(%rdx,%rbx) + QUAD $0x0001201a8411fcc5; BYTE $0x00 // vmovups %ymm0, $288(%rdx,%rbx) + QUAD $0x0001401a8411fcc5; BYTE $0x00 // vmovups %ymm0, $320(%rdx,%rbx) + QUAD $0x0001601a8411fcc5; BYTE $0x00 // vmovups %ymm0, $352(%rdx,%rbx) + QUAD $0x0001801a8411fcc5; BYTE $0x00 // vmovups %ymm0, $384(%rdx,%rbx) + QUAD $0x0001a01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $416(%rdx,%rbx) + QUAD $0x0001c01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $448(%rdx,%rbx) + QUAD $0x0001e01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $480(%rdx,%rbx) + LONG $0x00c38148; WORD $0x0002; BYTE $0x00 // addq $512, %rbx + LONG $0xfcc18349 // addq $-4, %r9 + LONG $0xff6c850f; WORD $0xffff // jne LBB14_8, $-148(%rip) + +LBB14_9: + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x003b840f; WORD $0x0000 // je LBB14_12, $59(%rip) + LONG $0x130c8d4c // leaq (%rbx,%rdx), %r9 + LONG $0x60c18349 // addq $96, %r9 + LONG $0x07e0c149 // shlq $7, %r8 + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + BYTE $0x90 // .p2align 4, 0x90 + +LBB14_11: + LONG $0x117cc1c4; WORD $0x1944; BYTE $0xa0 // vmovups %ymm0, $-96(%r9,%rbx) + LONG $0x117cc1c4; WORD $0x1944; BYTE $0xc0 // vmovups %ymm0, $-64(%r9,%rbx) + LONG $0x117cc1c4; WORD $0x1944; BYTE $0xe0 // vmovups %ymm0, $-32(%r9,%rbx) + LONG $0x117cc1c4; WORD $0x1904 // vmovups %ymm0, (%r9,%rbx) + LONG $0x80eb8348 // subq $-128, %rbx + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0xffd8850f; WORD $0xffff // jne LBB14_11, $-40(%rip) + +LBB14_12: + WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 + LONG $0x0050840f; WORD $0x0000 // je LBB14_18, $80(%rip) + WORD $0xc1f6; BYTE $0x70 // testb $112, %cl + LONG $0x0036840f; WORD $0x0000 // je LBB14_17, $54(%rip) + +LBB14_14: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0xf0e28349 // andq $-16, %r10 + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB14_15: + LONG $0x0411f8c5; BYTE $0x02 // vmovups %xmm0, (%rdx,%rax) + LONG $0x10c08348 // addq $16, %rax + WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 + LONG $0xffee850f; WORD $0xffff // jne LBB14_15, $-18(%rip) + WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 + LONG $0x0016840f; WORD $0x0000 // je LBB14_18, $22(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB14_17: + LONG $0x1204c642; BYTE $0x00 // movb $0, (%rdx,%r10) + WORD $0xff49; BYTE $0xc2 // incq %r10 + WORD $0x394c; BYTE $0xd1 // cmpq %r10, %rcx + LONG $0xffef850f; WORD $0xffff // jne LBB14_17, $-17(%rip) + +LBB14_18: + LONG $0x00c045c7; WORD $0x0000; BYTE $0x00 // movl $0, $-64(%rbp) + QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3f80; BYTE $0x2d // cmpb $45, (%rdi) + LONG $0x001b850f; WORD $0x0000 // jne LBB14_19, $27(%rip) + LONG $0x01c845c7; WORD $0x0000; BYTE $0x00 // movl $1, $-56(%rbp) + LONG $0x0001bd41; WORD $0x0000 // movl $1, %r13d + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0x00118c0f; WORD $0x0000 // jl LBB14_22, $17(%rip) + LONG $0x0001b5e9; BYTE $0x00 // jmp LBB14_54, $437(%rip) + +LBB14_19: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0x01a98d0f; WORD $0x0000 // jge LBB14_54, $425(%rip) + +LBB14_22: + WORD $0xb741; BYTE $0x01 // movb $1, %r15b + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x000027e9; BYTE $0x00 // jmp LBB14_23, $39(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB14_33: + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x8945; BYTE $0xdc // movl %r11d, %r12d + WORD $0x2e3c // cmpb $46, %al + LONG $0x0095850f; WORD $0x0000 // jne LBB14_36, $149(%rip) + +LBB14_34: + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0xc79c0f41 // setl %r15b + LONG $0x007c840f; WORD $0x0000 // je LBB14_35, $124(%rip) + +LBB14_23: + WORD $0x8941; BYTE $0xda // movl %ebx, %r10d + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + LONG $0x04b60f42; BYTE $0x2f // movzbl (%rdi,%r13), %eax + WORD $0x588d; BYTE $0xd0 // leal $-48(%rax), %ebx + WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl + LONG $0xffc9870f; WORD $0xffff // ja LBB14_33, $-55(%rip) + WORD $0x303c // cmpb $48, %al + LONG $0x0021850f; WORD $0x0000 // jne LBB14_29, $33(%rip) + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x0043840f; WORD $0x0000 // je LBB14_26, $67(%rip) + WORD $0x6349; BYTE $0xd8 // movslq %r8d, %rbx + WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx + LONG $0x0018820f; WORD $0x0000 // jb LBB14_32, $24(%rip) + LONG $0x000019e9; BYTE $0x00 // jmp LBB14_28, $25(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB14_29: + WORD $0x6349; BYTE $0xdb // movslq %r11d, %rbx + WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx + LONG $0x0014830f; WORD $0x0000 // jae LBB14_30, $20(%rip) + +LBB14_32: + WORD $0x0488; BYTE $0x1a // movb %al, (%rdx,%rbx) + WORD $0xff41; BYTE $0xc0 // incl %r8d + +LBB14_28: + WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d + WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d + WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx + LONG $0xffff90e9; BYTE $0xff // jmp LBB14_34, $-112(%rip) + +LBB14_30: + LONG $0x0001b941; WORD $0x0000 // movl $1, %r9d + LONG $0x000006e9; BYTE $0x00 // jmp LBB14_31, $6(%rip) + +LBB14_26: + WORD $0xff41; BYTE $0xce // decl %r14d + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + +LBB14_31: + WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d + WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx + LONG $0xffff74e9; BYTE $0xff // jmp LBB14_34, $-140(%rip) + +LBB14_35: + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 + WORD $0x8941; BYTE $0xda // movl %ebx, %r10d + +LBB14_36: + LONG $0xc4758944 // movl %r14d, $-60(%rbp) + LONG $0xcc4d8944 // movl %r9d, $-52(%rbp) + LONG $0xc0458944 // movl %r8d, $-64(%rbp) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0012840f; WORD $0x0000 // je LBB14_37, $18(%rip) + WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d + LONG $0x01c7f641 // testb $1, %r15b + LONG $0x0013850f; WORD $0x0000 // jne LBB14_40, $19(%rip) + LONG $0x0000c4e9; BYTE $0x00 // jmp LBB14_55, $196(%rip) + +LBB14_37: + LONG $0xc4458944 // movl %r8d, $-60(%rbp) + LONG $0x01c7f641 // testb $1, %r15b + LONG $0x00b6840f; WORD $0x0000 // je LBB14_55, $182(%rip) + +LBB14_40: + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0xc983; BYTE $0x20 // orl $32, %ecx + WORD $0xf983; BYTE $0x65 // cmpl $101, %ecx + LONG $0x00a3850f; WORD $0x0000 // jne LBB14_55, $163(%rip) + LONG $0x0754b60f; BYTE $0x01 // movzbl $1(%rdi,%rax), %edx + WORD $0xfa83; BYTE $0x2d // cmpl $45, %edx + LONG $0x0017840f; WORD $0x0000 // je LBB14_45, $23(%rip) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + WORD $0xfa83; BYTE $0x2b // cmpl $43, %edx + LONG $0x0028850f; WORD $0x0000 // jne LBB14_43, $40(%rip) + LONG $0x02c58341 // addl $2, %r13d + LONG $0x000009e9; BYTE $0x00 // jmp LBB14_46, $9(%rip) + +LBB14_45: + LONG $0x02c58341 // addl $2, %r13d + LONG $0xffffffb9; BYTE $0xff // movl $-1, %ecx + +LBB14_46: + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x00168c0f; WORD $0x0000 // jl LBB14_48, $22(%rip) + LONG $0x000055e9; BYTE $0x00 // jmp LBB14_53, $85(%rip) + +LBB14_43: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x00448d0f; WORD $0x0000 // jge LBB14_53, $68(%rip) + +LBB14_48: + WORD $0xc031 // xorl %eax, %eax + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB14_49: + LONG $0x171cbe0f // movsbl (%rdi,%rdx), %ebx + WORD $0xfb83; BYTE $0x30 // cmpl $48, %ebx + LONG $0x00298c0f; WORD $0x0000 // jl LBB14_53, $41(%rip) + WORD $0xfb80; BYTE $0x39 // cmpb $57, %bl + LONG $0x0020870f; WORD $0x0000 // ja LBB14_53, $32(%rip) + LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax + LONG $0x00158f0f; WORD $0x0000 // jg LBB14_53, $21(%rip) + WORD $0x048d; BYTE $0x80 // leal (%rax,%rax,4), %eax + WORD $0x048d; BYTE $0x43 // leal (%rbx,%rax,2), %eax + WORD $0xc083; BYTE $0xd0 // addl $-48, %eax + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffca850f; WORD $0xffff // jne LBB14_49, $-54(%rip) + +LBB14_53: + WORD $0xaf0f; BYTE $0xc1 // imull %ecx, %eax + WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d + +LBB14_54: + LONG $0xc4458944 // movl %r8d, $-60(%rbp) + +LBB14_55: + LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi + LONG $0xd0758d48 // leaq $-48(%rbp), %rsi + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0xfff650e8; BYTE $0xff // callq _decimal_to_f64, $-2480(%rip) + LONG $0x4510fbc5; BYTE $0xd0 // vmovsd $-48(%rbp), %xmm0 + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +_value: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x28ec8348 // subq $40, %rsp + WORD $0x894d; BYTE $0xc7 // movq %r8, %r15 + WORD $0x8949; BYTE $0xce // movq %rcx, %r14 + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 + LONG $0xd0558948 // movq %rdx, $-48(%rbp) + LONG $0xb07d8948 // movq %rdi, $-80(%rbp) + LONG $0xb8758948 // movq %rsi, $-72(%rbp) + LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi + LONG $0xd0758d48 // leaq $-48(%rbp), %rsi + LONG $0x00067ae8; BYTE $0x00 // callq _advance_ns, $1658(%rip) + WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax + WORD $0xf883; BYTE $0x7d // cmpl $125, %eax + LONG $0x00bc870f; WORD $0x0000 // ja LBB15_11, $188(%rip) + LONG $0x9f0d8d48; WORD $0x0003; BYTE $0x00 // leaq $927(%rip), %rcx /* LJTI15_0(%rip) */ + LONG $0x81046348 // movslq (%rcx,%rax,4), %rax + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + JMP AX + +LBB15_2: + LONG $0xc875894c // movq %r14, $-56(%rbp) + LONG $0xd0758b4c // movq $-48(%rbp), %r14 + LONG $0xff6e8d4d // leaq $-1(%r14), %r13 + LONG $0xd06d894c // movq %r13, $-48(%rbp) + LONG $0x02c7f641 // testb $2, %r15b + LONG $0x001a850f; WORD $0x0000 // jne LBB15_4, $26(%rip) + LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi + LONG $0xd0758d48 // leaq $-48(%rbp), %rsi + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + LONG $0x000e53e8; BYTE $0x00 // callq _vnumber, $3667(%rip) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x00034de9; BYTE $0x00 // jmp LBB15_58, $845(%rip) + +LBB15_4: + WORD $0xc031 // xorl %eax, %eax + LONG $0x2c3c8043; BYTE $0x2d // cmpb $45, (%r12,%r13) + LONG $0x2c3c8d4f // leaq (%r12,%r13), %r15 + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x2948; BYTE $0xc3 // subq %rax, %rbx + LONG $0x030c840f; WORD $0x0000 // je LBB15_53, $780(%rip) + WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 + LONG $0x000e830f; WORD $0x0000 // jae LBB15_7, $14(%rip) + LONG $0x07b60f41 // movzbl (%r15), %eax + WORD $0xc604 // addb $-58, %al + WORD $0xf63c // cmpb $-10, %al + LONG $0x0307820f; WORD $0x0000 // jb LBB15_55, $775(%rip) + +LBB15_7: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0x0020dee8; BYTE $0x00 // callq _do_skip_number, $8414(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x02ed880f; WORD $0x0000 // js LBB15_54, $749(%rip) + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x02f28e0f; WORD $0x0000 // jle LBB15_57, $754(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + LONG $0x0800c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rax) + LONG $0x1868894c // movq %r13, $24(%rax) + LONG $0x0002e5e9; BYTE $0x00 // jmp LBB15_58, $741(%rip) + +LBB15_10: + LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq $1, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x0002d5e9; BYTE $0x00 // jmp LBB15_58, $725(%rip) + +LBB15_11: + LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + WORD $0xff49; BYTE $0xcf // decq %r15 + LONG $0x0002c2e9; BYTE $0x00 // jmp LBB15_58, $706(%rip) + +LBB15_12: + QUAD $0xffffffffc045c748 // movq $-1, $-64(%rbp) + LONG $0xd0658b4c // movq $-48(%rbp), %r12 + LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi + LONG $0xc0558d48 // leaq $-64(%rbp), %rdx + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + LONG $0x000980e8; BYTE $0x00 // callq _advance_string, $2432(%rip) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0174880f; WORD $0x0000 // js LBB15_32, $372(%rip) + LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0x1066894d // movq %r12, $16(%r14) + LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0xc84c0f48 // cmovlq %rax, %rcx + LONG $0x184e8949 // movq %rcx, $24(%r14) + LONG $0x00026de9; BYTE $0x00 // jmp LBB15_58, $621(%rip) + +LBB15_14: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000bba; BYTE $0x00 // movl $11, %edx + LONG $0x00011ae9; BYTE $0x00 // jmp LBB15_31, $282(%rip) + +LBB15_15: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + LONG $0x000100e9; BYTE $0x00 // jmp LBB15_31, $256(%rip) + +LBB15_16: + LONG $0x0506c749; WORD $0x0000; BYTE $0x00 // movq $5, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x000229e9; BYTE $0x00 // jmp LBB15_58, $553(%rip) + +LBB15_17: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000cba; BYTE $0x00 // movl $12, %edx + LONG $0x0000d6e9; BYTE $0x00 // jmp LBB15_31, $214(%rip) + +LBB15_18: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0xfc4b8d48 // leaq $-4(%rbx), %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x008a870f; WORD $0x0000 // ja LBB15_25, $138(%rip) + LONG $0x3c0c8b43 // movl (%r12,%r15), %ecx + LONG $0x6c61f981; WORD $0x6573 // cmpl $1702063201, %ecx + LONG $0x00d3850f; WORD $0x0000 // jne LBB15_33, $211(%rip) + LONG $0x04c78349 // addq $4, %r15 + LONG $0x000004b8; BYTE $0x00 // movl $4, %eax + LONG $0x000069e9; BYTE $0x00 // jmp LBB15_24, $105(%rip) + +LBB15_21: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x0054870f; WORD $0x0000 // ja LBB15_25, $84(%rip) + LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx + LONG $0x756ef981; WORD $0x6c6c // cmpl $1819047278, %ecx + LONG $0x00db850f; WORD $0x0000 // jne LBB15_37, $219(%rip) + LONG $0x03c78349 // addq $3, %r15 + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + LONG $0x000032e9; BYTE $0x00 // jmp LBB15_24, $50(%rip) + +LBB15_26: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x001d870f; WORD $0x0000 // ja LBB15_25, $29(%rip) + LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx + LONG $0x7274f981; WORD $0x6575 // cmpl $1702195828, %ecx + LONG $0x00e2850f; WORD $0x0000 // jne LBB15_41, $226(%rip) + LONG $0x03c78349 // addq $3, %r15 + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + +LBB15_24: + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + +LBB15_25: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x00015ee9; BYTE $0x00 // jmp LBB15_58, $350(%rip) + +LBB15_29: + LONG $0x0606c749; WORD $0x0000; BYTE $0x00 // movq $6, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x00014ee9; BYTE $0x00 // jmp LBB15_58, $334(%rip) + +LBB15_30: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000dba; BYTE $0x00 // movl $13, %edx + +LBB15_31: + LONG $0xd1440f48 // cmoveq %rcx, %rdx + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 + LONG $0x000123e9; BYTE $0x00 // jmp LBB15_58, $291(%rip) + +LBB15_32: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x894d; BYTE $0x3e // movq %r15, (%r14) + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x000114e9; BYTE $0x00 // jmp LBB15_58, $276(%rip) + +LBB15_33: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xf980; BYTE $0x61 // cmpb $97, %cl + LONG $0x00d5850f; WORD $0x0000 // jne LBB15_49, $213(%rip) + LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) + LONG $0x00aa850f; WORD $0x0000 // jne LBB15_46, $170(%rip) + LONG $0x3c7c8043; WORD $0x7302 // cmpb $115, $2(%r12,%r15) + LONG $0x00b5850f; WORD $0x0000 // jne LBB15_47, $181(%rip) + LONG $0x044f8d49 // leaq $4(%r15), %rcx + LONG $0x3c7c8043; WORD $0x6503 // cmpb $101, $3(%r12,%r15) + LONG $0x037f8d4d // leaq $3(%r15), %r15 + LONG $0xf9440f4c // cmoveq %rcx, %r15 + LONG $0x0000a2e9; BYTE $0x00 // jmp LBB15_48, $162(%rip) + +LBB15_37: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xf980; BYTE $0x6e // cmpb $110, %cl + LONG $0x006c850f; WORD $0x0000 // jne LBB15_45, $108(%rip) + LONG $0x3c3c8043; BYTE $0x75 // cmpb $117, (%r12,%r15) + LONG $0x0077850f; WORD $0x0000 // jne LBB15_51, $119(%rip) + LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) + LONG $0x0068850f; WORD $0x0000 // jne LBB15_50, $104(%rip) + LONG $0x034f8d49 // leaq $3(%r15), %rcx + LONG $0x3c7c8043; WORD $0x6c02 // cmpb $108, $2(%r12,%r15) + LONG $0x027f8d4d // leaq $2(%r15), %r15 + LONG $0xf9440f4c // cmoveq %rcx, %r15 + LONG $0x000054e9; BYTE $0x00 // jmp LBB15_51, $84(%rip) + +LBB15_41: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xf980; BYTE $0x74 // cmpb $116, %cl + LONG $0x002e850f; WORD $0x0000 // jne LBB15_45, $46(%rip) + LONG $0x3c3c8043; BYTE $0x72 // cmpb $114, (%r12,%r15) + LONG $0x0039850f; WORD $0x0000 // jne LBB15_51, $57(%rip) + LONG $0x3c7c8043; WORD $0x7501 // cmpb $117, $1(%r12,%r15) + LONG $0x002a850f; WORD $0x0000 // jne LBB15_50, $42(%rip) + LONG $0x034f8d49 // leaq $3(%r15), %rcx + LONG $0x3c7c8043; WORD $0x6502 // cmpb $101, $2(%r12,%r15) + LONG $0x027f8d4d // leaq $2(%r15), %r15 + LONG $0xf9440f4c // cmoveq %rcx, %r15 + LONG $0x000016e9; BYTE $0x00 // jmp LBB15_51, $22(%rip) + +LBB15_45: + WORD $0xff49; BYTE $0xcf // decq %r15 + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x00004ee9; BYTE $0x00 // jmp LBB15_58, $78(%rip) + +LBB15_46: + WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0x000013e9; BYTE $0x00 // jmp LBB15_48, $19(%rip) + +LBB15_50: + WORD $0xff49; BYTE $0xc7 // incq %r15 + +LBB15_51: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x000037e9; BYTE $0x00 // jmp LBB15_58, $55(%rip) + +LBB15_47: + LONG $0x02c78349 // addq $2, %r15 + +LBB15_48: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + +LBB15_49: + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x000027e9; BYTE $0x00 // jmp LBB15_58, $39(%rip) + +LBB15_53: + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + LONG $0x00000de9; BYTE $0x00 // jmp LBB15_56, $13(%rip) + +LBB15_54: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + +LBB15_55: + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + +LBB15_56: + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + LONG $0xd07d894c // movq %r15, $-48(%rbp) + +LBB15_57: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) + +LBB15_58: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90 + + // .set L15_0_set_10, LBB15_10-LJTI15_0 + // .set L15_0_set_11, LBB15_11-LJTI15_0 + // .set L15_0_set_12, LBB15_12-LJTI15_0 + // .set L15_0_set_14, LBB15_14-LJTI15_0 + // .set L15_0_set_2, LBB15_2-LJTI15_0 + // .set L15_0_set_15, LBB15_15-LJTI15_0 + // .set L15_0_set_16, LBB15_16-LJTI15_0 + // .set L15_0_set_17, LBB15_17-LJTI15_0 + // .set L15_0_set_18, LBB15_18-LJTI15_0 + // .set L15_0_set_21, LBB15_21-LJTI15_0 + // .set L15_0_set_26, LBB15_26-LJTI15_0 + // .set L15_0_set_29, LBB15_29-LJTI15_0 + // .set L15_0_set_30, LBB15_30-LJTI15_0 +LJTI15_0: + LONG $0xfffffd06 // .long L15_0_set_10 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd29 // .long L15_0_set_12 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd7e // .long L15_0_set_14 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffd98 // .long L15_0_set_15 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffdb2 // .long L15_0_set_16 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffdc2 // .long L15_0_set_17 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffddc // .long L15_0_set_18 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe12 // .long L15_0_set_21 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe49 // .long L15_0_set_26 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe8d // .long L15_0_set_29 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe9d // .long L15_0_set_30 + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .p2align 5, 0x00 + +LCPI16_0: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + +LCPI16_1: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI16_2: + QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' + QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' + +LCPI16_3: + QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + + // .p2align 4, 0x00 +LCPI16_4: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + +LCPI16_5: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI16_6: + QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' + +LCPI16_7: + QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + + // .p2align 4, 0x90 +_advance_ns: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + WORD $0x8b4c; BYTE $0x1e // movq (%rsi), %r11 + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0x08478b4c // movq $8(%rdi), %r8 + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0x0021830f; WORD $0x0000 // jae LBB16_4, $33(%rip) + LONG $0x04b60f43; BYTE $0x19 // movzbl (%r9,%r11), %eax + WORD $0xf883; BYTE $0x0d // cmpl $13, %eax + LONG $0x0013840f; WORD $0x0000 // je LBB16_4, $19(%rip) + WORD $0xf883; BYTE $0x20 // cmpl $32, %eax + LONG $0x000a840f; WORD $0x0000 // je LBB16_4, $10(%rip) + WORD $0xf504 // addb $-11, %al + WORD $0xfe3c // cmpb $-2, %al + LONG $0x0284820f; WORD $0x0000 // jb LBB16_48, $644(%rip) + +LBB16_4: + LONG $0x01438d49 // leaq $1(%r11), %rax + WORD $0x394c; BYTE $0xc0 // cmpq %r8, %rax + LONG $0x0023830f; WORD $0x0000 // jae LBB16_9, $35(%rip) + LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx + LONG $0x0015840f; WORD $0x0000 // je LBB16_9, $21(%rip) + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x000c840f; WORD $0x0000 // je LBB16_9, $12(%rip) + WORD $0xc180; BYTE $0xf5 // addb $-11, %cl + WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl + LONG $0x0060820f; WORD $0x0000 // jb LBB16_8, $96(%rip) + +LBB16_9: + LONG $0x02438d49 // leaq $2(%r11), %rax + WORD $0x394c; BYTE $0xc0 // cmpq %r8, %rax + LONG $0x0023830f; WORD $0x0000 // jae LBB16_14, $35(%rip) + LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx + LONG $0x0015840f; WORD $0x0000 // je LBB16_14, $21(%rip) + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x000c840f; WORD $0x0000 // je LBB16_14, $12(%rip) + WORD $0xc180; BYTE $0xf5 // addb $-11, %cl + WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl + LONG $0x0030820f; WORD $0x0000 // jb LBB16_8, $48(%rip) + +LBB16_14: + LONG $0x03438d49 // leaq $3(%r11), %rax + WORD $0x394c; BYTE $0xc0 // cmpq %r8, %rax + LONG $0x002b830f; WORD $0x0000 // jae LBB16_19, $43(%rip) + LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx + LONG $0x001d840f; WORD $0x0000 // je LBB16_19, $29(%rip) + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x0014840f; WORD $0x0000 // je LBB16_19, $20(%rip) + WORD $0xc180; BYTE $0xf5 // addb $-11, %cl + WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl + LONG $0x0008830f; WORD $0x0000 // jae LBB16_19, $8(%rip) + +LBB16_8: + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + LONG $0x0001ece9; BYTE $0x00 // jmp LBB16_48, $492(%rip) + +LBB16_19: + LONG $0x04c38349 // addq $4, %r11 + WORD $0x394d; BYTE $0xd8 // cmpq %r11, %r8 + LONG $0x01bf860f; WORD $0x0000 // jbe LBB16_44, $447(%rip) + LONG $0x191c8d4b // leaq (%r9,%r11), %rbx + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + WORD $0x294c; BYTE $0xd9 // subq %r11, %rcx + LONG $0x0068840f; WORD $0x0000 // je LBB16_28, $104(%rip) + WORD $0xd889 // movl %ebx, %eax + WORD $0xe083; BYTE $0x1f // andl $31, %eax + LONG $0x005d840f; WORD $0x0000 // je LBB16_28, $93(%rip) + LONG $0x000005ba; BYTE $0x00 // movl $5, %edx + WORD $0x294c; BYTE $0xc2 // subq %r8, %rdx + QUAD $0x000100002600b948; WORD $0x0000 // movabsq $4294977024, %rcx + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB16_23: + LONG $0x04be0f43; BYTE $0x19 // movsbl (%r9,%r11), %eax + WORD $0xf883; BYTE $0x20 // cmpl $32, %eax + LONG $0x0193870f; WORD $0x0000 // ja LBB16_46, $403(%rip) + LONG $0xc1a30f48 // btq %rax, %rcx + LONG $0x0189830f; WORD $0x0000 // jae LBB16_46, $393(%rip) + LONG $0x1a1c8d4a // leaq (%rdx,%r11), %rbx + LONG $0x01438d49 // leaq $1(%r11), %rax + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x0012840f; WORD $0x0000 // je LBB16_27, $18(%rip) + LONG $0x191c8d43 // leal (%r9,%r11), %ebx + WORD $0xc3ff // incl %ebx + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + WORD $0xe383; BYTE $0x1f // andl $31, %ebx + LONG $0xffc4850f; WORD $0xffff // jne LBB16_23, $-60(%rip) + +LBB16_27: + LONG $0x011c8d49 // leaq (%r9,%rax), %rbx + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + WORD $0x2948; BYTE $0xc1 // subq %rax, %rcx + +LBB16_28: + LONG $0x20f98348 // cmpq $32, %rcx + LONG $0x0073820f; WORD $0x0000 // jb LBB16_32, $115(%rip) + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax + QUAD $0xfffffdd2056ffdc5 // vmovdqa $-558(%rip), %ymm0 /* LCPI16_0(%rip) */ + QUAD $0xfffffdea0d6ffdc5 // vmovdqa $-534(%rip), %ymm1 /* LCPI16_1(%rip) */ + QUAD $0xfffffe02156ffdc5 // vmovdqa $-510(%rip), %ymm2 /* LCPI16_2(%rip) */ + QUAD $0xfffffe1a1d6ffdc5 // vmovdqa $-486(%rip), %ymm3 /* LCPI16_3(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB16_30: + LONG $0x236ffdc5 // vmovdqa (%rbx), %ymm4 + LONG $0xe874ddc5 // vpcmpeqb %ymm0, %ymm4, %ymm5 + LONG $0xf174ddc5 // vpcmpeqb %ymm1, %ymm4, %ymm6 + LONG $0xeeebd5c5 // vpor %ymm6, %ymm5, %ymm5 + LONG $0xf274ddc5 // vpcmpeqb %ymm2, %ymm4, %ymm6 + LONG $0xe374ddc5 // vpcmpeqb %ymm3, %ymm4, %ymm4 + LONG $0xe6ebddc5 // vpor %ymm6, %ymm4, %ymm4 + LONG $0xe5ebddc5 // vpor %ymm5, %ymm4, %ymm4 + LONG $0xd4d7fdc5 // vpmovmskb %ymm4, %edx + WORD $0xfa83; BYTE $0xff // cmpl $-1, %edx + LONG $0x00e8850f; WORD $0x0000 // jne LBB16_45, $232(%rip) + LONG $0x20c38348 // addq $32, %rbx + LONG $0xe0c18348 // addq $-32, %rcx + LONG $0xe0c08348 // addq $-32, %rax + LONG $0x1ff98348 // cmpq $31, %rcx + LONG $0xffbd870f; WORD $0xffff // ja LBB16_30, $-67(%rip) + +LBB16_32: + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x10f98348 // cmpq $16, %rcx + LONG $0x006a820f; WORD $0x0000 // jb LBB16_36, $106(%rip) + WORD $0x894d; BYTE $0xca // movq %r9, %r10 + WORD $0x2949; BYTE $0xda // subq %rbx, %r10 + QUAD $0xfffffdd2056ff9c5 // vmovdqa $-558(%rip), %xmm0 /* LCPI16_4(%rip) */ + QUAD $0xfffffdda0d6ff9c5 // vmovdqa $-550(%rip), %xmm1 /* LCPI16_5(%rip) */ + QUAD $0xfffffde2156ff9c5 // vmovdqa $-542(%rip), %xmm2 /* LCPI16_6(%rip) */ + QUAD $0xfffffdea1d6ff9c5 // vmovdqa $-534(%rip), %xmm3 /* LCPI16_7(%rip) */ + +LBB16_34: + LONG $0x236ff9c5 // vmovdqa (%rbx), %xmm4 + LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 + LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 + LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 + LONG $0xf274d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm6 + LONG $0xe374d9c5 // vpcmpeqb %xmm3, %xmm4, %xmm4 + LONG $0xe6ebd9c5 // vpor %xmm6, %xmm4, %xmm4 + LONG $0xe5ebd9c5 // vpor %xmm5, %xmm4, %xmm4 + LONG $0xc4d7f9c5 // vpmovmskb %xmm4, %eax + LONG $0xfff88366 // cmpw $-1, %ax + LONG $0x009b850f; WORD $0x0000 // jne LBB16_49, $155(%rip) + LONG $0x10c38348 // addq $16, %rbx + LONG $0xf0c18348 // addq $-16, %rcx + LONG $0xf0c28349 // addq $-16, %r10 + LONG $0x0ff98348 // cmpq $15, %rcx + LONG $0xffbc870f; WORD $0xffff // ja LBB16_34, $-68(%rip) + +LBB16_36: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0036840f; WORD $0x0000 // je LBB16_42, $54(%rip) + LONG $0x0b148d4c // leaq (%rbx,%rcx), %r10 + WORD $0xc031 // xorl %eax, %eax + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + +LBB16_38: + LONG $0x0314be0f // movsbl (%rbx,%rax), %edx + WORD $0xfa83; BYTE $0x20 // cmpl $32, %edx + LONG $0x007c870f; WORD $0x0000 // ja LBB16_51, $124(%rip) + LONG $0xd3a30f49 // btq %rdx, %r11 + LONG $0x0072830f; WORD $0x0000 // jae LBB16_51, $114(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffdd850f; WORD $0xffff // jne LBB16_38, $-35(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + +LBB16_42: + WORD $0x294c; BYTE $0xcb // subq %r9, %rbx + WORD $0x8949; BYTE $0xdb // movq %rbx, %r11 + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0x0022820f; WORD $0x0000 // jb LBB16_47, $34(%rip) + LONG $0x000047e9; BYTE $0x00 // jmp LBB16_50, $71(%rip) + +LBB16_44: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) + LONG $0x00003fe9; BYTE $0x00 // jmp LBB16_50, $63(%rip) + +LBB16_45: + WORD $0xf8c5; BYTE $0x77 // vzeroupper + WORD $0xd2f7 // notl %edx + LONG $0xdabc0f44 // bsfl %edx, %r11d + WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 + +LBB16_46: + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0x002a830f; WORD $0x0000 // jae LBB16_50, $42(%rip) + +LBB16_47: + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + +LBB16_48: + LONG $0x01438d49 // leaq $1(%r11), %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0x04b60f43; BYTE $0x19 // movzbl (%r9,%r11), %eax + WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB16_49: + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0xd0f7 // notl %eax + LONG $0xd8bc0f44 // bsfl %eax, %r11d + WORD $0x294d; BYTE $0xd3 // subq %r10, %r11 + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0xffd6820f; WORD $0xffff // jb LBB16_47, $-42(%rip) + +LBB16_50: + WORD $0xc031 // xorl %eax, %eax + WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB16_51: + WORD $0x294c; BYTE $0xcb // subq %r9, %rbx + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x8949; BYTE $0xdb // movq %rbx, %r11 + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0xffbc820f; WORD $0xffff // jb LBB16_47, $-68(%rip) + LONG $0xffffe1e9; BYTE $0xff // jmp LBB16_50, $-31(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +_vstring: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x10ec8348 // subq $16, %rsp + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + QUAD $0xffffffffd845c748 // movq $-1, $-40(%rbp) + WORD $0x8b4c; BYTE $0x26 // movq (%rsi), %r12 + LONG $0xd8558d48 // leaq $-40(%rbp), %rdx + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0x0000c1e8; BYTE $0x00 // callq _advance_string, $193(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0029880f; WORD $0x0000 // js LBB17_1, $41(%rip) + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0x1066894d // movq %r12, $16(%r14) + LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) + LONG $0xd84d8b48 // movq $-40(%rbp), %rcx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xc14c0f48 // cmovlq %rcx, %rax + LONG $0x18468949 // movq %rax, $24(%r14) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB17_3, $10(%rip) + +LBB17_1: + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + +LBB17_3: + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .p2align 5, 0x00 + +LCPI18_0: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI18_1: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI18_2: + QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' + QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' + + // .p2align 4, 0x90 +_advance_string: + WORD $0xc1f6; BYTE $0x20 // testb $32, %cl + LONG $0x0005850f; WORD $0x0000 // jne LBB18_2, $5(%rip) + LONG $0x005132e9; BYTE $0x00 // jmp _advance_string_default, $20786(%rip) + +LBB18_2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x087f8b4c // movq $8(%rdi), %r15 + WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 + LONG $0x03a7840f; WORD $0x0000 // je LBB18_27, $935(%rip) + WORD $0x8b4c; BYTE $0x1f // movq (%rdi), %r11 + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + LONG $0x40ff8349 // cmpq $64, %r15 + LONG $0x01f4820f; WORD $0x0000 // jb LBB18_28, $500(%rip) + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + QUAD $0xffffff52056ffdc5 // vmovdqa $-174(%rip), %ymm0 /* LCPI18_0(%rip) */ + QUAD $0xffffff6a0d6ffdc5 // vmovdqa $-150(%rip), %ymm1 /* LCPI18_1(%rip) */ + QUAD $0xffffff82156ffdc5 // vmovdqa $-126(%rip), %ymm2 /* LCPI18_2(%rip) */ + QUAD $0xaaaaaaaaaaaab949; WORD $0xaaaa // movabsq $-6148914691236517206, %r9 + QUAD $0x555555555555ba49; WORD $0x5555 // movabsq $6148914691236517205, %r10 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB18_5: + LONG $0x6f7ec1c4; WORD $0x331c // vmovdqu (%r11,%rsi), %ymm3 + LONG $0x6f7ec1c4; WORD $0x3364; BYTE $0x20 // vmovdqu $32(%r11,%rsi), %ymm4 + LONG $0xe874e5c5 // vpcmpeqb %ymm0, %ymm3, %ymm5 + LONG $0xe5d77dc5 // vpmovmskb %ymm5, %r12d + LONG $0xe874ddc5 // vpcmpeqb %ymm0, %ymm4, %ymm5 + LONG $0xcdd7fdc5 // vpmovmskb %ymm5, %ecx + LONG $0xe974e5c5 // vpcmpeqb %ymm1, %ymm3, %ymm5 + LONG $0xc5d7fdc5 // vpmovmskb %ymm5, %eax + LONG $0xe974ddc5 // vpcmpeqb %ymm1, %ymm4, %ymm5 + LONG $0xddd7fdc5 // vpmovmskb %ymm5, %ebx + LONG $0xeadaddc5 // vpminub %ymm2, %ymm4, %ymm5 + LONG $0xe574ddc5 // vpcmpeqb %ymm5, %ymm4, %ymm4 + LONG $0xfcd7fdc5 // vpmovmskb %ymm4, %edi + LONG $0x20e1c148 // shlq $32, %rcx + WORD $0x0949; BYTE $0xcc // orq %rcx, %r12 + LONG $0x20e3c148 // shlq $32, %rbx + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0948; BYTE $0xd8 // orq %rbx, %rax + LONG $0x0044850f; WORD $0x0000 // jne LBB18_11, $68(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x004f850f; WORD $0x0000 // jne LBB18_13, $79(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + +LBB18_8: + LONG $0xe2dae5c5 // vpminub %ymm2, %ymm3, %ymm4 + LONG $0xdc74e5c5 // vpcmpeqb %ymm4, %ymm3, %ymm3 + LONG $0xc3d7fdc5 // vpmovmskb %ymm3, %eax + WORD $0x0948; BYTE $0xc7 // orq %rax, %rdi + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x006e850f; WORD $0x0000 // jne LBB18_14, $110(%rip) + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x00b3850f; WORD $0x0000 // jne LBB18_20, $179(%rip) + LONG $0xc0c78349 // addq $-64, %r15 + LONG $0x40c68348 // addq $64, %rsi + LONG $0x3fff8349 // cmpq $63, %r15 + LONG $0xff70870f; WORD $0xffff // ja LBB18_5, $-144(%rip) + LONG $0x0000bce9; BYTE $0x00 // jmp LBB18_22, $188(%rip) + +LBB18_11: + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x000a850f; WORD $0x0000 // jne LBB18_13, $10(%rip) + LONG $0xc0bc0f4c // bsfq %rax, %r8 + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + +LBB18_13: + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + LONG $0x092c8d4c // leaq (%rcx,%rcx), %r13 + WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 + WORD $0x894c; BYTE $0xeb // movq %r13, %rbx + WORD $0xf748; BYTE $0xd3 // notq %rbx + WORD $0x2148; BYTE $0xc3 // andq %rax, %rbx + WORD $0x214c; BYTE $0xcb // andq %r9, %rbx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xc6920f41 // setb %r14b + WORD $0x0148; BYTE $0xdb // addq %rbx, %rbx + WORD $0x314c; BYTE $0xd3 // xorq %r10, %rbx + WORD $0x214c; BYTE $0xeb // andq %r13, %rbx + WORD $0xf748; BYTE $0xd3 // notq %rbx + WORD $0x2149; BYTE $0xdc // andq %rbx, %r12 + LONG $0xffff7ae9; BYTE $0xff // jmp LBB18_8, $-134(%rip) + +LBB18_14: + LONG $0xc4bc0f49 // bsfq %r12, %rax + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0021840f; WORD $0x0000 // je LBB18_18, $33(%rip) + LONG $0xcfbc0f48 // bsfq %rdi, %rcx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x0022820f; WORD $0x0000 // jb LBB18_19, $34(%rip) + +LBB18_16: + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + +LBB18_17: + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB18_18: + LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffde830f; WORD $0xffff // jae LBB18_16, $-34(%rip) + +LBB18_19: + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xffffd2e9; BYTE $0xff // jmp LBB18_17, $-46(%rip) + +LBB18_20: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0xffc1850f; WORD $0xffff // jne LBB18_17, $-63(%rip) + LONG $0xcfbc0f48 // bsfq %rdi, %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0xffffb2e9; BYTE $0xff // jmp LBB18_17, $-78(%rip) + +LBB18_22: + WORD $0x014c; BYTE $0xde // addq %r11, %rsi + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x0107820f; WORD $0x0000 // jb LBB18_38, $263(%rip) + +LBB18_23: + LONG $0x066ffec5 // vmovdqu (%rsi), %ymm0 + QUAD $0xfffffdb60d74fdc5 // vpcmpeqb $-586(%rip), %ymm0, %ymm1 /* LCPI18_0(%rip) */ + LONG $0xc9d77dc5 // vpmovmskb %ymm1, %r9d + QUAD $0xfffffdca0d74fdc5 // vpcmpeqb $-566(%rip), %ymm0, %ymm1 /* LCPI18_1(%rip) */ + LONG $0xc1d7fdc5 // vpmovmskb %ymm1, %eax + QUAD $0xfffffdde0ddafdc5 // vpminub $-546(%rip), %ymm0, %ymm1 /* LCPI18_2(%rip) */ + LONG $0xc174fdc5 // vpcmpeqb %ymm1, %ymm0, %ymm0 + WORD $0xc085 // testl %eax, %eax + LONG $0x003e850f; WORD $0x0000 // jne LBB18_29, $62(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x004f850f; WORD $0x0000 // jne LBB18_31, $79(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0xd8d7fdc5 // vpmovmskb %ymm0, %ebx + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x007c840f; WORD $0x0000 // je LBB18_32, $124(%rip) + +LBB18_26: + LONG $0xd1bc0f4d // bsfq %r9, %r10 + LONG $0x000079e9; BYTE $0x00 // jmp LBB18_33, $121(%rip) + +LBB18_28: + WORD $0x014c; BYTE $0xde // addq %r11, %rsi + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0xff97830f; WORD $0xffff // jae LBB18_23, $-105(%rip) + LONG $0x000099e9; BYTE $0x00 // jmp LBB18_38, $153(%rip) + +LBB18_29: + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x0010850f; WORD $0x0000 // jne LBB18_31, $16(%rip) + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + WORD $0x294c; BYTE $0xd9 // subq %r11, %rcx + LONG $0xc0bc0f4c // bsfq %rax, %r8 + WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + +LBB18_31: + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xc121 // andl %eax, %ecx + WORD $0x3c8d; BYTE $0x09 // leal (%rcx,%rcx), %edi + LONG $0x4e1c8d41 // leal (%r14,%rcx,2), %ebx + WORD $0xd7f7 // notl %edi + WORD $0xc721 // andl %eax, %edi + LONG $0xaaaae781; WORD $0xaaaa // andl $-1431655766, %edi + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0xcf01 // addl %ecx, %edi + LONG $0xc6920f41 // setb %r14b + WORD $0xff01 // addl %edi, %edi + LONG $0x5555f781; WORD $0x5555 // xorl $1431655765, %edi + WORD $0xdf21 // andl %ebx, %edi + WORD $0xd7f7 // notl %edi + WORD $0x2141; BYTE $0xf9 // andl %edi, %r9d + LONG $0xd8d7fdc5 // vpmovmskb %ymm0, %ebx + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xff84850f; WORD $0xffff // jne LBB18_26, $-124(%rip) + +LBB18_32: + LONG $0x0040ba41; WORD $0x0000 // movl $64, %r10d + +LBB18_33: + WORD $0xbc0f; BYTE $0xc3 // bsfl %ebx, %eax + LONG $0x000040bf; BYTE $0x00 // movl $64, %edi + WORD $0x450f; BYTE $0xf8 // cmovnel %eax, %edi + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0018840f; WORD $0x0000 // je LBB18_36, $24(%rip) + WORD $0x294c; BYTE $0xde // subq %r11, %rsi + WORD $0x3949; BYTE $0xfa // cmpq %rdi, %r10 + LONG $0x00ad870f; WORD $0x0000 // ja LBB18_49, $173(%rip) + LONG $0x16048d4a // leaq (%rsi,%r10), %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xfffeaee9; BYTE $0xff // jmp LBB18_17, $-338(%rip) + +LBB18_36: + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x00a1850f; WORD $0x0000 // jne LBB18_50, $161(%rip) + LONG $0x20c68348 // addq $32, %rsi + LONG $0xe0c78349 // addq $-32, %r15 + +LBB18_38: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x00a7850f; WORD $0x0000 // jne LBB18_51, $167(%rip) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xfe85840f; WORD $0xffff // je LBB18_17, $-379(%rip) + +LBB18_40: + WORD $0xb60f; BYTE $0x3e // movzbl (%rsi), %edi + WORD $0xff83; BYTE $0x22 // cmpl $34, %edi + LONG $0x005e840f; WORD $0x0000 // je LBB18_48, $94(%rip) + WORD $0xff83; BYTE $0x5c // cmpl $92, %edi + LONG $0x0027840f; WORD $0x0000 // je LBB18_45, $39(%rip) + LONG $0x1fff8040 // cmpb $31, %dil + LONG $0x00be860f; WORD $0x0000 // jbe LBB18_55, $190(%rip) + LONG $0xffc7c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdi + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + +LBB18_44: + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + WORD $0x0149; BYTE $0xff // addq %rdi, %r15 + LONG $0xffc9850f; WORD $0xffff // jne LBB18_40, $-55(%rip) + LONG $0xfffe49e9; BYTE $0xff // jmp LBB18_17, $-439(%rip) + +LBB18_45: + LONG $0x01ff8349 // cmpq $1, %r15 + LONG $0xfe3f840f; WORD $0xffff // je LBB18_17, $-449(%rip) + LONG $0xfec7c748; WORD $0xffff; BYTE $0xff // movq $-2, %rdi + LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0xffcf850f; WORD $0xffff // jne LBB18_44, $-49(%rip) + WORD $0x8949; BYTE $0xf0 // movq %rsi, %r8 + WORD $0x294d; BYTE $0xd8 // subq %r11, %r8 + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + LONG $0xffffc1e9; BYTE $0xff // jmp LBB18_44, $-63(%rip) + +LBB18_48: + WORD $0x294c; BYTE $0xde // subq %r11, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0xfffe0de9; BYTE $0xff // jmp LBB18_17, $-499(%rip) + +LBB18_49: + WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi + LONG $0x000060e9; BYTE $0x00 // jmp LBB18_56, $96(%rip) + +LBB18_50: + WORD $0x294c; BYTE $0xde // subq %r11, %rsi + WORD $0xc089 // movl %eax, %eax + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xfffdeee9; BYTE $0xff // jmp LBB18_17, $-530(%rip) + +LBB18_51: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0031840f; WORD $0x0000 // je LBB18_27, $49(%rip) + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x000c850f; WORD $0x0000 // jne LBB18_54, $12(%rip) + WORD $0x894d; BYTE $0xd8 // movq %r11, %r8 + WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + +LBB18_54: + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff49; BYTE $0xcf // decq %r15 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xff34850f; WORD $0xffff // jne LBB18_40, $-204(%rip) + LONG $0xfffdb4e9; BYTE $0xff // jmp LBB18_17, $-588(%rip) + +LBB18_27: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffda8e9; BYTE $0xff // jmp LBB18_17, $-600(%rip) + +LBB18_55: + WORD $0x294c; BYTE $0xde // subq %r11, %rsi + +LBB18_56: + WORD $0x8948; BYTE $0x32 // movq %rsi, (%rdx) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xfffd96e9; BYTE $0xff // jmp LBB18_17, $-618(%rip) + WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI19_0: + LONG $0x43300000 // .long 1127219200 + LONG $0x45300000 // .long 1160773632 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + +LCPI19_1: + QUAD $0x4330000000000000 // .quad 0x4330000000000000 + QUAD $0x4530000000000000 // .quad 0x4530000000000000 + + // .p2align 3, 0x00 +LCPI19_2: + QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000 + +LCPI19_3: + QUAD $0xc30c6bf526340000 // .quad 0xc30c6bf526340000 + + // .p2align 4, 0x90 +_vnumber: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x38ec8348 // subq $56, %rsp + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax + WORD $0x8b4c; BYTE $0x3f // movq (%rdi), %r15 + LONG $0x086f8b4c // movq $8(%rdi), %r13 + LONG $0x20528b4c // movq $32(%rdx), %r10 + LONG $0x285a8b4c // movq $40(%rdx), %r11 + LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) + LONG $0xc057f9c5 // vxorpd %xmm0, %xmm0, %xmm0 + LONG $0x4211f9c5; BYTE $0x08 // vmovupd %xmm0, $8(%rdx) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + LONG $0x184a8948 // movq %rcx, $24(%rdx) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x02c9830f; WORD $0x0000 // jae LBB19_51, $713(%rip) + LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx + LONG $0x000001bf; BYTE $0x00 // movl $1, %edi + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl + LONG $0x0016850f; WORD $0x0000 // jne LBB19_4, $22(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x02aa830f; WORD $0x0000 // jae LBB19_51, $682(%rip) + LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx + LONG $0xffffffbf; BYTE $0xff // movl $-1, %edi + +LBB19_4: + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB19_6, $15(%rip) + +LBB19_5: + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) + LONG $0x00028fe9; BYTE $0x00 // jmp LBB19_52, $655(%rip) + +LBB19_6: + WORD $0xf980; BYTE $0x30 // cmpb $48, %cl + LONG $0x0032850f; WORD $0x0000 // jne LBB19_10, $50(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00a6830f; WORD $0x0000 // jae LBB19_18, $166(%rip) + LONG $0x14b60f41; BYTE $0x0f // movzbl (%r15,%rcx), %edx + WORD $0xc283; BYTE $0xd2 // addl $-46, %edx + WORD $0xfa83; BYTE $0x37 // cmpl $55, %edx + LONG $0x0095870f; WORD $0x0000 // ja LBB19_18, $149(%rip) + QUAD $0x000000800001be48; WORD $0x0080 // movabsq $36028797027352577, %rsi + LONG $0xd6a30f48 // btq %rdx, %rsi + LONG $0x0081830f; WORD $0x0000 // jae LBB19_18, $129(%rip) + +LBB19_10: + WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) + WORD $0x01b1 // movb $1, %cl + WORD $0x4d89; BYTE $0xc8 // movl %ecx, $-56(%rbp) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0063830f; WORD $0x0000 // jae LBB19_17, $99(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x000012e9; BYTE $0x00 // jmp LBB19_13, $18(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB19_12: + WORD $0xc1ff // incl %ecx + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0x0036840f; WORD $0x0000 // je LBB19_16, $54(%rip) + +LBB19_13: + LONG $0x14be0f49; BYTE $0x07 // movsbq (%r15,%rax), %rdx + WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x0041870f; WORD $0x0000 // ja LBB19_19, $65(%rip) + LONG $0x12f88341 // cmpl $18, %r8d + LONG $0xffd68f0f; WORD $0xffff // jg LBB19_12, $-42(%rip) + LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi + WORD $0x0144; BYTE $0xca // addl %r9d, %edx + LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 + WORD $0xff41; BYTE $0xc0 // incl %r8d + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0xffca850f; WORD $0xffff // jne LBB19_13, $-54(%rip) + +LBB19_16: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + LONG $0x00005be9; BYTE $0x00 // jmp LBB19_24, $91(%rip) + +LBB19_17: + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x00004ee9; BYTE $0x00 // jmp LBB19_24, $78(%rip) + +LBB19_18: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x0001cbe9; BYTE $0x00 // jmp LBB19_52, $459(%rip) + +LBB19_19: + WORD $0xfa80; BYTE $0x2e // cmpb $46, %dl + LONG $0x003d850f; WORD $0x0000 // jne LBB19_24, $61(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + WORD $0x394c; BYTE $0xea // cmpq %r13, %rdx + LONG $0x01a4830f; WORD $0x0000 // jae LBB19_51, $420(%rip) + LONG $0x44b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %eax + WORD $0xc604 // addb $-58, %al + WORD $0xf53c // cmpb $-11, %al + LONG $0x000f870f; WORD $0x0000 // ja LBB19_23, $15(%rip) + WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) + LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) + LONG $0x00018fe9; BYTE $0x00 // jmp LBB19_52, $399(%rip) + +LBB19_23: + LONG $0x00c845c7; WORD $0x0000; BYTE $0x00 // movl $0, $-56(%rbp) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + +LBB19_24: + WORD $0xd231 // xorl %edx, %edx + WORD $0xc985 // testl %ecx, %ecx + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x5589; BYTE $0xbc // movl %edx, $-68(%rbp) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x005d850f; WORD $0x0000 // jne LBB19_33, $93(%rip) + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0055850f; WORD $0x0000 // jne LBB19_33, $85(%rip) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0044830f; WORD $0x0000 // jae LBB19_31, $68(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xee // subl %r13d, %esi + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB19_28: + LONG $0x073c8041; BYTE $0x30 // cmpb $48, (%r15,%rax) + LONG $0x0029850f; WORD $0x0000 // jne LBB19_32, $41(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0xc9ff // decl %ecx + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0xffe7850f; WORD $0xffff // jne LBB19_28, $-25(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax + WORD $0xc084 // testb %al, %al + LONG $0x0144850f; WORD $0x0000 // jne LBB19_54, $324(%rip) + +LBB19_59: + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0x000173e9; BYTE $0x00 // jmp LBB19_60, $371(%rip) + +LBB19_31: + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + +LBB19_32: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + +LBB19_33: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x004c830f; WORD $0x0000 // jae LBB19_39, $76(%rip) + LONG $0x12f88341 // cmpl $18, %r8d + LONG $0x00428f0f; WORD $0x0000 // jg LBB19_39, $66(%rip) + LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d + + // .p2align 4, 0x90 +LBB19_36: + LONG $0x14b60f41; BYTE $0x07 // movzbl (%r15,%rax), %edx + WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x002a870f; WORD $0x0000 // ja LBB19_39, $42(%rip) + LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi + WORD $0x0144; BYTE $0xca // addl %r9d, %edx + LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 + WORD $0xc9ff // decl %ecx + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0011830f; WORD $0x0000 // jae LBB19_39, $17(%rip) + LONG $0x01508d41 // leal $1(%r8), %edx + LONG $0x12f88341 // cmpl $18, %r8d + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + LONG $0xffc48c0f; WORD $0xffff // jl LBB19_36, $-60(%rip) + +LBB19_39: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00c6830f; WORD $0x0000 // jae LBB19_53, $198(%rip) + LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x0030870f; WORD $0x0000 // ja LBB19_45, $48(%rip) + LONG $0xff558d49 // leaq $-1(%r13), %rdx + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB19_42: + WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx + LONG $0x0180840f; WORD $0x0000 // je LBB19_58, $384(%rip) + LONG $0x74b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %esi + WORD $0x7e8d; BYTE $0xd0 // leal $-48(%rsi), %edi + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0xffe1860f; WORD $0xffff // jbe LBB19_42, $-31(%rip) + LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) + +LBB19_45: + LONG $0xd6b60f40 // movzbl %sil, %edx + WORD $0xca83; BYTE $0x20 // orl $32, %edx + WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx + LONG $0x0075850f; WORD $0x0000 // jne LBB19_53, $117(%rip) + LONG $0x01788d48 // leaq $1(%rax), %rdi + LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + WORD $0x394c; BYTE $0xef // cmpq %r13, %rdi + LONG $0x0048830f; WORD $0x0000 // jae LBB19_51, $72(%rip) + LONG $0x34b60f41; BYTE $0x3f // movzbl (%r15,%rdi), %esi + WORD $0xfe83; BYTE $0x2d // cmpl $45, %esi + LONG $0x000f840f; WORD $0x0000 // je LBB19_49, $15(%rip) + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + WORD $0xfe83; BYTE $0x2b // cmpl $43, %esi + LONG $0x02a8850f; WORD $0x0000 // jne LBB19_86, $680(%rip) + +LBB19_49: + LONG $0x02c08348 // addq $2, %rax + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0x001b830f; WORD $0x0000 // jae LBB19_51, $27(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x2bfe8040 // cmpb $43, %sil + LONG $0xc7940f40 // sete %dil + LONG $0x3f048d44 // leal (%rdi,%rdi), %r8d + WORD $0xff41; BYTE $0xc8 // decl %r8d + LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi + LONG $0x000283e9; BYTE $0x00 // jmp LBB19_87, $643(%rip) + +LBB19_51: + WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) + LONG $0xff03c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rbx) + +LBB19_52: + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB19_53: + WORD $0xce89 // movl %ecx, %esi + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax + WORD $0xc084 // testb %al, %al + LONG $0xfebc840f; WORD $0xffff // je LBB19_59, $-324(%rip) + +LBB19_54: + WORD $0xf685 // testl %esi, %esi + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0x0025850f; WORD $0x0000 // jne LBB19_57, $37(%rip) + QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax + WORD $0x6348; BYTE $0xca // movslq %edx, %rcx + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x00e7890f; WORD $0x0000 // jns LBB19_68, $231(%rip) + WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00d8840f; WORD $0x0000 // je LBB19_68, $216(%rip) + +LBB19_57: + LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + +LBB19_60: + LONG $0x6ef9c1c4; BYTE $0xc4 // vmovq %r12, %xmm0 + QUAD $0xfffffc510562f9c5 // vpunpckldq $-943(%rip), %xmm0, %xmm0 /* LCPI19_0(%rip) */ + QUAD $0x00000000b045c748 // movq $0, $-80(%rbp) + QUAD $0xfffffc51055cf9c5 // vsubpd $-943(%rip), %xmm0, %xmm0 /* LCPI19_1(%rip) */ + LONG $0x0579e3c4; WORD $0x01c8 // vpermilpd $1, %xmm0, %xmm1 + LONG $0xc058f3c5 // vaddsd %xmm0, %xmm1, %xmm0 + LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0x34e8c148 // shrq $52, %rax + LONG $0x010d850f; WORD $0x0000 // jne LBB19_73, $269(%rip) + LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx + WORD $0xd089 // movl %edx, %eax + WORD $0xe8c1; BYTE $0x1f // shrl $31, %eax + LONG $0x3fe0c148 // shlq $63, %rax + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xc0458948 // movq %rax, $-64(%rbp) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x018a840f; WORD $0x0000 // je LBB19_81, $394(%rip) + WORD $0xf685 // testl %esi, %esi + LONG $0x0182840f; WORD $0x0000 // je LBB19_81, $386(%rip) + LONG $0x6ef9e1c4; BYTE $0xc0 // vmovq %rax, %xmm0 + WORD $0x468d; BYTE $0xff // leal $-1(%rsi), %eax + WORD $0xf883; BYTE $0x24 // cmpl $36, %eax + LONG $0x0040870f; WORD $0x0000 // ja LBB19_66, $64(%rip) + WORD $0xfe83; BYTE $0x17 // cmpl $23, %esi + LONG $0x0093820f; WORD $0x0000 // jb LBB19_69, $147(%rip) + WORD $0x468d; BYTE $0xea // leal $-22(%rsi), %eax + LONG $0xab0d8d48; WORD $0x00ed; BYTE $0x00 // leaq $60843(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0x0459fbc5; BYTE $0xc1 // vmulsd (%rcx,%rax,8), %xmm0, %xmm0 + LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x000016b8; BYTE $0x00 // movl $22, %eax + LONG $0x000077e9; BYTE $0x00 // jmp LBB19_70, $119(%rip) + +LBB19_58: + LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) + WORD $0xce89 // movl %ecx, %esi + WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax + WORD $0xc084 // testb %al, %al + LONG $0xff1e850f; WORD $0xffff // jne LBB19_54, $-226(%rip) + LONG $0xfffdd5e9; BYTE $0xff // jmp LBB19_59, $-555(%rip) + +LBB19_66: + WORD $0xfe83; BYTE $0xea // cmpl $-22, %esi + LONG $0x008d820f; WORD $0x0000 // jb LBB19_73, $141(%rip) + WORD $0xdef7 // negl %esi + LONG $0x6c058d48; WORD $0x00ed; BYTE $0x00 // leaq $60780(%rip), %rax /* _P10_TAB(%rip) */ + LONG $0x045efbc5; BYTE $0xf0 // vdivsd (%rax,%rsi,8), %xmm0, %xmm0 + LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x0000d7e9; BYTE $0x00 // jmp LBB19_77, $215(%rip) + +LBB19_68: + LONG $0x6ef9c1c4; BYTE $0xc4 // vmovq %r12, %xmm0 + LONG $0xe1af0f4c // imulq %rcx, %r12 + QUAD $0xfffffb7c0562f9c5 // vpunpckldq $-1156(%rip), %xmm0, %xmm0 /* LCPI19_0(%rip) */ + QUAD $0xfffffb84055cf9c5 // vsubpd $-1148(%rip), %xmm0, %xmm0 /* LCPI19_1(%rip) */ + LONG $0x1063894c // movq %r12, $16(%rbx) + LONG $0x0579e3c4; WORD $0x01c8 // vpermilpd $1, %xmm0, %xmm1 + LONG $0xc058f3c5 // vaddsd %xmm0, %xmm1, %xmm0 + WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax + LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + LONG $0x084b8948 // movq %rcx, $8(%rbx) + LONG $0x000109e9; BYTE $0x00 // jmp LBB19_85, $265(%rip) + +LBB19_69: + WORD $0xf089 // movl %esi, %eax + +LBB19_70: + QUAD $0xfffffb68052ef9c5 // vucomisd $-1176(%rip), %xmm0 /* LCPI19_2(%rip) */ + LONG $0x002a870f; WORD $0x0000 // ja LBB19_73, $42(%rip) + QUAD $0xfffffb620d10fbc5 // vmovsd $-1182(%rip), %xmm1 /* LCPI19_3(%rip) */ + LONG $0xc82ef9c5 // vucomisd %xmm0, %xmm1 + LONG $0x0018870f; WORD $0x0000 // ja LBB19_73, $24(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0xf70d8d48; WORD $0x00ec; BYTE $0x00 // leaq $60663(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0x0459fbc5; BYTE $0xc1 // vmulsd (%rcx,%rax,8), %xmm0, %xmm0 + LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x000062e9; BYTE $0x00 // jmp LBB19_77, $98(%rip) + +LBB19_73: + LONG $0xa05d894c // movq %r11, $-96(%rbp) + LONG $0xc855894c // movq %r10, $-56(%rbp) + LONG $0xc04d8d48 // leaq $-64(%rbp), %rcx + WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi + LONG $0xa8758948 // movq %rsi, $-88(%rbp) + LONG $0xffe0c0e8; BYTE $0xff // callq _atof_eisel_lemire64, $-8000(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x004c840f; WORD $0x0000 // je LBB19_79, $76(%rip) + LONG $0x00bc7d83 // cmpl $0, $-68(%rbp) + LONG $0x006d840f; WORD $0x0000 // je LBB19_80, $109(%rip) + WORD $0xff49; BYTE $0xc4 // incq %r12 + LONG $0xb04d8d48 // leaq $-80(%rbp), %rcx + WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi + LONG $0xa8758b48 // movq $-88(%rbp), %rsi + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0xffe098e8; BYTE $0xff // callq _atof_eisel_lemire64, $-8040(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x0024840f; WORD $0x0000 // je LBB19_79, $36(%rip) + LONG $0x4d10fbc5; BYTE $0xb0 // vmovsd $-80(%rbp), %xmm1 + LONG $0x4510fbc5; BYTE $0xc0 // vmovsd $-64(%rbp), %xmm0 + LONG $0xc82ef9c5 // vucomisd %xmm0, %xmm1 + LONG $0x0010850f; WORD $0x0000 // jne LBB19_79, $16(%rip) + LONG $0x000a8a0f; WORD $0x0000 // jp LBB19_79, $10(%rip) + +LBB19_77: + LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq %xmm0, %rax + LONG $0x00002fe9; BYTE $0x00 // jmp LBB19_81, $47(%rip) + +LBB19_79: + WORD $0x8b49; BYTE $0x06 // movq (%r14), %rax + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + LONG $0xa04d8b48 // movq $-96(%rbp), %rcx + LONG $0xffe810e8; BYTE $0xff // callq _atof_native, $-6128(%rip) + LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq %xmm0, %rax + LONG $0x000009e9; BYTE $0x00 // jmp LBB19_82, $9(%rip) + +LBB19_80: + LONG $0xc0458b48 // movq $-64(%rbp), %rax + +LBB19_81: + LONG $0x6ef9e1c4; BYTE $0xc0 // vmovq %rax, %xmm0 + +LBB19_82: + QUAD $0x000000000000b948; WORD $0x8000 // movabsq $-9223372036854775808, %rcx + WORD $0xff48; BYTE $0xc9 // decq %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + QUAD $0x000000000000b848; WORD $0x7ff0 // movabsq $9218868437227405312, %rax + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x0007850f; WORD $0x0000 // jne LBB19_84, $7(%rip) + LONG $0xf803c748; WORD $0xffff; BYTE $0xff // movq $-8, (%rbx) + +LBB19_84: + LONG $0x4311fbc5; BYTE $0x08 // vmovsd %xmm0, $8(%rbx) + +LBB19_85: + WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) + LONG $0xfffd8de9; BYTE $0xff // jmp LBB19_52, $-627(%rip) + +LBB19_86: + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + +LBB19_87: + LONG $0xc6c68040 // addb $-58, %sil + LONG $0xf6fe8040 // cmpb $-10, %sil + LONG $0xfadb820f; WORD $0xffff // jb LBB19_5, $-1317(%rip) + WORD $0xf631 // xorl %esi, %esi + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0035830f; WORD $0x0000 // jae LBB19_93, $53(%rip) + WORD $0xf631 // xorl %esi, %esi + +LBB19_90: + LONG $0x0cb60f45; BYTE $0x07 // movzbl (%r15,%rax), %r9d + LONG $0xd0798d41 // leal $-48(%r9), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x0020870f; WORD $0x0000 // ja LBB19_93, $32(%rip) + LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi + WORD $0x3c8d; BYTE $0xb6 // leal (%rsi,%rsi,4), %edi + LONG $0x797c8d41; BYTE $0xd0 // leal $-48(%r9,%rdi,2), %edi + WORD $0x4c0f; BYTE $0xf7 // cmovll %edi, %esi + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0xffd0850f; WORD $0xffff // jne LBB19_90, $-48(%rip) + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + +LBB19_93: + LONG $0xf0af0f41 // imull %r8d, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0xfffd81e9; BYTE $0xff // jmp LBB19_60, $-639(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_vsigned: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + LONG $0x4211f8c5; BYTE $0x08 // vmovups %xmm0, $8(%rdx) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + LONG $0x184a8948 // movq %rcx, $24(%rdx) + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x0046830f; WORD $0x0000 // jae LBB20_1, $70(%rip) + LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl + LONG $0x0018850f; WORD $0x0000 // jne LBB20_5, $24(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x0026830f; WORD $0x0000 // jae LBB20_1, $38(%rip) + LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + +LBB20_5: + WORD $0x798d; BYTE $0xc6 // leal $-58(%rcx), %edi + LONG $0xf5ff8040 // cmpb $-11, %dil + LONG $0x001a870f; WORD $0x0000 // ja LBB20_7, $26(%rip) + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfe02c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_1: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_7: + WORD $0xf980; BYTE $0x30 // cmpb $48, %cl + LONG $0x0032850f; WORD $0x0000 // jne LBB20_12, $50(%rip) + LONG $0x01508d4c // leaq $1(%rax), %r10 + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x007f830f; WORD $0x0000 // jae LBB20_11, $127(%rip) + LONG $0x3cb60f43; BYTE $0x11 // movzbl (%r9,%r10), %edi + WORD $0xc783; BYTE $0xd2 // addl $-46, %edi + WORD $0xff83; BYTE $0x37 // cmpl $55, %edi + LONG $0x006e870f; WORD $0x0000 // ja LBB20_11, $110(%rip) + QUAD $0x000000800001b948; WORD $0x0080 // movabsq $36028797027352577, %rcx + LONG $0xf9a30f48 // btq %rdi, %rcx + LONG $0x005a830f; WORD $0x0000 // jae LBB20_11, $90(%rip) + +LBB20_12: + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xd0470f4c // cmovaq %rax, %r10 + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB20_13: + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x007d830f; WORD $0x0000 // jae LBB20_23, $125(%rip) + LONG $0x3cbe0f49; BYTE $0x01 // movsbq (%r9,%rax), %rdi + WORD $0x5f8d; BYTE $0xd0 // leal $-48(%rdi), %ebx + WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl + LONG $0x0033870f; WORD $0x0000 // ja LBB20_18, $51(%rip) + LONG $0x0ac96b48 // imulq $10, %rcx, %rcx + LONG $0x0013800f; WORD $0x0000 // jo LBB20_17, $19(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0xc783; BYTE $0xd0 // addl $-48, %edi + LONG $0xf8af0f49 // imulq %r8, %rdi + WORD $0x0148; BYTE $0xf9 // addq %rdi, %rcx + LONG $0xffc9810f; WORD $0xffff // jno LBB20_13, $-55(%rip) + +LBB20_17: + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfb02c748; WORD $0xffff; BYTE $0xff // movq $-5, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_11: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_18: + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x002d830f; WORD $0x0000 // jae LBB20_22, $45(%rip) + LONG $0x3cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %edi + WORD $0xff83; BYTE $0x2e // cmpl $46, %edi + LONG $0x0012840f; WORD $0x0000 // je LBB20_25, $18(%rip) + WORD $0xff83; BYTE $0x45 // cmpl $69, %edi + LONG $0x0009840f; WORD $0x0000 // je LBB20_25, $9(%rip) + WORD $0xff83; BYTE $0x65 // cmpl $101, %edi + LONG $0x000d850f; WORD $0x0000 // jne LBB20_22, $13(%rip) + +LBB20_25: + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfa02c748; WORD $0xffff; BYTE $0xff // movq $-6, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_22: + WORD $0x8949; BYTE $0xc2 // movq %rax, %r10 + +LBB20_23: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + LONG $0x104a8948 // movq %rcx, $16(%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + + // .p2align 4, 0x90 +_vunsigned: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0x08778b4c // movq $8(%rdi), %r14 + LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + LONG $0x4211f8c5; BYTE $0x08 // vmovups %xmm0, $8(%rdx) + WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax + LONG $0x18428948 // movq %rax, $24(%rdx) + WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx + LONG $0x001c830f; WORD $0x0000 // jae LBB21_1, $28(%rip) + LONG $0x04b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %eax + WORD $0x2d3c // cmpb $45, %al + LONG $0x001e850f; WORD $0x0000 // jne LBB21_4, $30(%rip) + +LBB21_3: + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfa00c749; WORD $0xffff; BYTE $0xff // movq $-6, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_1: + WORD $0x894c; BYTE $0x36 // movq %r14, (%rsi) + LONG $0xff00c749; WORD $0xffff; BYTE $0xff // movq $-1, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_4: + WORD $0x508d; BYTE $0xc6 // leal $-58(%rax), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB21_6, $15(%rip) + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfe00c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_6: + WORD $0x303c // cmpb $48, %al + LONG $0x0026850f; WORD $0x0000 // jne LBB21_10, $38(%rip) + LONG $0x44b60f41; WORD $0x0109 // movzbl $1(%r9,%rcx), %eax + WORD $0xc083; BYTE $0xd2 // addl $-46, %eax + WORD $0xf883; BYTE $0x37 // cmpl $55, %eax + LONG $0x00c0870f; WORD $0x0000 // ja LBB21_9, $192(%rip) + QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx + LONG $0xc2a30f48 // btq %rax, %rdx + LONG $0x00ac830f; WORD $0x0000 // jae LBB21_9, $172(%rip) + +LBB21_10: + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0xd6470f4d // cmovaq %r14, %r10 + WORD $0xc031 // xorl %eax, %eax + LONG $0x000abb41; WORD $0x0000 // movl $10, %r11d + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB21_11: + WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx + LONG $0x007f830f; WORD $0x0000 // jae LBB21_22, $127(%rip) + LONG $0x1cbe0f41; BYTE $0x09 // movsbl (%r9,%rcx), %ebx + WORD $0x538d; BYTE $0xd0 // leal $-48(%rbx), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x0042870f; WORD $0x0000 // ja LBB21_17, $66(%rip) + WORD $0xf749; BYTE $0xe3 // mulq %r11 + LONG $0x0027800f; WORD $0x0000 // jo LBB21_16, $39(%rip) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0xc383; BYTE $0xd0 // addl $-48, %ebx + WORD $0xff31 // xorl %edi, %edi + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0xc7920f40 // setb %dil + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + WORD $0xf748; BYTE $0xda // negq %rdx + WORD $0x3148; BYTE $0xd7 // xorq %rdx, %rdi + LONG $0x0009850f; WORD $0x0000 // jne LBB21_16, $9(%rip) + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffb6890f; WORD $0xffff // jns LBB21_11, $-74(%rip) + +LBB21_16: + WORD $0xff48; BYTE $0xc9 // decq %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfb00c749; WORD $0xffff; BYTE $0xff // movq $-5, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_17: + WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx + LONG $0x0020830f; WORD $0x0000 // jae LBB21_21, $32(%rip) + LONG $0x14b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %edx + WORD $0xfa83; BYTE $0x2e // cmpl $46, %edx + LONG $0xff0e840f; WORD $0xffff // je LBB21_3, $-242(%rip) + WORD $0xfa83; BYTE $0x45 // cmpl $69, %edx + LONG $0xff05840f; WORD $0xffff // je LBB21_3, $-251(%rip) + WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx + LONG $0xfefc840f; WORD $0xffff // je LBB21_3, $-260(%rip) + +LBB21_21: + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + +LBB21_22: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + LONG $0x10408949 // movq %rax, $16(%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_9: + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + BYTE $0x00 // .p2align 4, 0x00 + +LCPI22_0: + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000005 // .quad 5 + + // .p2align 4, 0x90 +_skip_array: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI22_0(%rip) */ + LONG $0x0011f8c5 // vmovups %xmm0, (%rax) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0x00000ee9; BYTE $0x00 // jmp _fsm_exec, $14(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_fsm_exec: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x18ec8348 // subq $24, %rsp + LONG $0xc04d8948 // movq %rcx, $-64(%rbp) + LONG $0x003f8348 // cmpq $0, (%rdi) + LONG $0x03f4840f; WORD $0x0000 // je LBB23_2, $1012(%rip) + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 + LONG $0xc8758948 // movq %rsi, $-56(%rbp) + LONG $0x000034e9; BYTE $0x00 // jmp LBB23_7, $52(%rip) + +LBB23_3: + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x000006b8; BYTE $0x00 // movl $6, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0x03df8f0f; WORD $0x0000 // jg LBB23_65, $991(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB23_4: + LONG $0x01518d48 // leaq $1(%rcx), %rdx + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + +LBB23_5: + LONG $0xd7448949; BYTE $0x08 // movq %rax, $8(%r15,%rdx,8) + +LBB23_6: + LONG $0x003f8349 // cmpq $0, (%r15) + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0x03f7840f; WORD $0x0000 // je LBB23_56, $1015(%rip) + +LBB23_7: + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xffee69e8; BYTE $0xff // callq _advance_ns, $-4503(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x0394840f; WORD $0x0000 // je LBB23_2, $916(%rip) + LONG $0xfffc8349 // cmpq $-1, %r12 + LONG $0x0006850f; WORD $0x0000 // jne LBB23_10, $6(%rip) + WORD $0x8b4c; BYTE $0x23 // movq (%rbx), %r12 + WORD $0xff49; BYTE $0xcc // decq %r12 + +LBB23_10: + WORD $0xbe0f; BYTE $0xf0 // movsbl %al, %esi + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + LONG $0xcf3c8b41 // movl (%r15,%rcx,8), %edi + WORD $0xcfff // decl %edi + WORD $0xff83; BYTE $0x05 // cmpl $5, %edi + LONG $0x0036870f; WORD $0x0000 // ja LBB23_14, $54(%rip) + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + WORD $0x894d; BYTE $0xe6 // movq %r12, %r14 + WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 + LONG $0xc41d8d48; WORD $0x0004; BYTE $0x00 // leaq $1220(%rip), %rbx /* LJTI23_0(%rip) */ + LONG $0xbb3c6348 // movslq (%rbx,%rdi,4), %rdi + WORD $0x0148; BYTE $0xdf // addq %rbx, %rdi + JMP DI + +LBB23_12: + WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0x019a840f; WORD $0x0000 // je LBB23_33, $410(%rip) + WORD $0xfe83; BYTE $0x5d // cmpl $93, %esi + WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 + LONG $0x0177840f; WORD $0x0000 // je LBB23_32, $375(%rip) + LONG $0x000367e9; BYTE $0x00 // jmp LBB23_61, $871(%rip) + +LBB23_14: + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi + LONG $0x00b4860f; WORD $0x0000 // jbe LBB23_25, $180(%rip) + LONG $0x00036de9; BYTE $0x00 // jmp LBB23_56, $877(%rip) + +LBB23_15: + WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 + LONG $0x014b840f; WORD $0x0000 // je LBB23_32, $331(%rip) + WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi + LONG $0x0337850f; WORD $0x0000 // jne LBB23_61, $823(%rip) + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 + LONG $0xff2d8e0f; WORD $0xffff // jle LBB23_4, $-211(%rip) + LONG $0x000304e9; BYTE $0x00 // jmp LBB23_65, $772(%rip) + +LBB23_18: + WORD $0x223c // cmpb $34, %al + LONG $0x0315850f; WORD $0x0000 // jne LBB23_61, $789(%rip) + QUAD $0x00000004cf04c749 // movq $4, (%r15,%rcx,8) + WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi + LONG $0x241c8b49 // movq (%r12), %rbx + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xd0558d48 // leaq $-48(%rbp), %rdx + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + LONG $0xfff191e8; BYTE $0xff // callq _advance_string, $-3695(%rip) + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0126890f; WORD $0x0000 // jns LBB23_35, $294(%rip) + LONG $0xd0458b48 // movq $-48(%rbp), %rax + LONG $0x000126e9; BYTE $0x00 // jmp LBB23_36, $294(%rip) + +LBB23_21: + WORD $0x3a3c // cmpb $58, %al + LONG $0x02d9850f; WORD $0x0000 // jne LBB23_61, $729(%rip) + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + WORD $0xc031 // xorl %eax, %eax + WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 + WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 + LONG $0xfffedee9; BYTE $0xff // jmp LBB23_5, $-290(%rip) + +LBB23_23: + WORD $0x5d3c // cmpb $93, %al + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 + LONG $0x00c6840f; WORD $0x0000 // je LBB23_32, $198(%rip) + QUAD $0x00000001cf04c749 // movq $1, (%r15,%rcx,8) + WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi + LONG $0x02be870f; WORD $0x0000 // ja LBB23_56, $702(%rip) + +LBB23_25: + WORD $0xf189 // movl %esi, %ecx + LONG $0xe6158d48; WORD $0x0003; BYTE $0x00 // leaq $998(%rip), %rdx /* LJTI23_1(%rip) */ + LONG $0x8a0c6348 // movslq (%rdx,%rcx,4), %rcx + WORD $0x0148; BYTE $0xd1 // addq %rdx, %rcx + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + JMP CX + +LBB23_26: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + WORD $0x8b4c; BYTE $0x33 // movq (%rbx), %r14 + LONG $0xff6e8d4d // leaq $-1(%r14), %r13 + WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi + WORD $0x014c; BYTE $0xef // addq %r13, %rdi + LONG $0x08708b48 // movq $8(%rax), %rsi + WORD $0x294c; BYTE $0xee // subq %r13, %rsi + LONG $0x0007f6e8; BYTE $0x00 // callq _do_skip_number, $2038(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0255880f; WORD $0x0000 // js LBB23_60, $597(%rip) + WORD $0x8b48; BYTE $0x0b // movq (%rbx), %rcx + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0xc8758b4c // movq $-56(%rbp), %r14 + LONG $0xfe638f0f; WORD $0xffff // jg LBB23_6, $-413(%rip) + LONG $0x000219e9; BYTE $0x00 // jmp LBB23_57, $537(%rip) + +LBB23_28: + WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 + LONG $0x0040840f; WORD $0x0000 // je LBB23_32, $64(%rip) + WORD $0xfe83; BYTE $0x22 // cmpl $34, %esi + LONG $0x022c850f; WORD $0x0000 // jne LBB23_61, $556(%rip) + QUAD $0x00000002cf04c749 // movq $2, (%r15,%rcx,8) + WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi + WORD $0x8949; BYTE $0xde // movq %rbx, %r14 + WORD $0x8b4c; BYTE $0x33 // movq (%rbx), %r14 + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0xd0558d48 // leaq $-48(%rbp), %rdx + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + LONG $0xfff0a6e8; BYTE $0xff // callq _advance_string, $-3930(%rip) + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0063890f; WORD $0x0000 // jns LBB23_37, $99(%rip) + LONG $0xd0458b48 // movq $-48(%rbp), %rax + LONG $0x000063e9; BYTE $0x00 // jmp LBB23_38, $99(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB23_32: + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 + LONG $0xfe0a850f; WORD $0xffff // jne LBB23_7, $-502(%rip) + LONG $0x0001b3e9; BYTE $0x00 // jmp LBB23_57, $435(%rip) + +LBB23_33: + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0x01b88f0f; WORD $0x0000 // jg LBB23_65, $440(%rip) + WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 + WORD $0xc031 // xorl %eax, %eax + WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 + LONG $0xfffdcfe9; BYTE $0xff // jmp LBB23_4, $-561(%rip) + +LBB23_35: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 + +LBB23_36: + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0x24048949 // movq %rax, (%r12) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0xfdbb890f; WORD $0xffff // jns LBB23_6, $-581(%rip) + LONG $0x000171e9; BYTE $0x00 // jmp LBB23_57, $369(%rip) + +LBB23_37: + WORD $0xff49; BYTE $0xce // decq %r14 + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 + +LBB23_38: + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xc8758b4c // movq $-56(%rbp), %r14 + LONG $0x0158880f; WORD $0x0000 // js LBB23_57, $344(%rip) + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x000004b8; BYTE $0x00 // movl $4, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0xfd798e0f; WORD $0xffff // jle LBB23_4, $-647(%rip) + LONG $0x000150e9; BYTE $0x00 // jmp LBB23_65, $336(%rip) + +LBB23_40: + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x8949; BYTE $0xde // movq %rbx, %r14 + WORD $0x8b48; BYTE $0x1b // movq (%rbx), %rbx + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xd0558d48 // leaq $-48(%rbp), %rdx + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + LONG $0xffefebe8; BYTE $0xff // callq _advance_string, $-4117(%rip) + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x00f1890f; WORD $0x0000 // jns LBB23_53, $241(%rip) + LONG $0xd0458b48 // movq $-48(%rbp), %rax + LONG $0x0000f1e9; BYTE $0x00 // jmp LBB23_54, $241(%rip) + +LBB23_42: + WORD $0x8b4c; BYTE $0x2b // movq (%rbx), %r13 + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + WORD $0x014c; BYTE $0xef // addq %r13, %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x294c; BYTE $0xee // subq %r13, %rsi + LONG $0x0006b1e8; BYTE $0x00 // callq _do_skip_number, $1713(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0143880f; WORD $0x0000 // js LBB23_70, $323(%rip) + WORD $0x0148; BYTE $0x03 // addq %rax, (%rbx) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfd2b8f0f; WORD $0xffff // jg LBB23_6, $-725(%rip) + LONG $0x000144e9; BYTE $0x00 // jmp LBB23_72, $324(%rip) + +LBB23_44: + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x000005b8; BYTE $0x00 // movl $5, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0xfd028e0f; WORD $0xffff // jle LBB23_4, $-766(%rip) + LONG $0x0000d9e9; BYTE $0x00 // jmp LBB23_65, $217(%rip) + +LBB23_45: + WORD $0x8b48; BYTE $0x03 // movq (%rbx), %rax + LONG $0x084e8b49 // movq $8(%r14), %rcx + LONG $0xfc518d48 // leaq $-4(%rcx), %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0x00ea870f; WORD $0x0000 // ja LBB23_67, $234(%rip) + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + WORD $0x148b; BYTE $0x01 // movl (%rcx,%rax), %edx + LONG $0x6c61fa81; WORD $0x6573 // cmpl $1702063201, %edx + LONG $0x015b850f; WORD $0x0000 // jne LBB23_77, $347(%rip) + LONG $0x04488d48 // leaq $4(%rax), %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfcd68f0f; WORD $0xffff // jg LBB23_6, $-810(%rip) + LONG $0x0000d2e9; BYTE $0x00 // jmp LBB23_68, $210(%rip) + +LBB23_48: + WORD $0x8b48; BYTE $0x03 // movq (%rbx), %rax + LONG $0x084e8b49 // movq $8(%r14), %rcx + LONG $0xfd518d48 // leaq $-3(%rcx), %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0x00af870f; WORD $0x0000 // ja LBB23_67, $175(%rip) + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + QUAD $0x6c6c756eff017c81 // cmpl $1819047278, $-1(%rcx,%rax) + LONG $0x002a840f; WORD $0x0000 // je LBB23_52, $42(%rip) + LONG $0x0000cde9; BYTE $0x00 // jmp LBB23_73, $205(%rip) + +LBB23_50: + WORD $0x8b48; BYTE $0x03 // movq (%rbx), %rax + LONG $0x084e8b49 // movq $8(%r14), %rcx + LONG $0xfd518d48 // leaq $-3(%rcx), %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0x0085870f; WORD $0x0000 // ja LBB23_67, $133(%rip) + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + QUAD $0x65757274ff017c81 // cmpl $1702195828, $-1(%rcx,%rax) + LONG $0x0149850f; WORD $0x0000 // jne LBB23_82, $329(%rip) + +LBB23_52: + LONG $0x03488d48 // leaq $3(%rax), %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfc728f0f; WORD $0xffff // jg LBB23_6, $-910(%rip) + LONG $0x00006ee9; BYTE $0x00 // jmp LBB23_68, $110(%rip) + +LBB23_53: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 + +LBB23_54: + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xc8758b4c // movq $-56(%rbp), %r14 + LONG $0xfc51890f; WORD $0xffff // jns LBB23_6, $-943(%rip) + LONG $0x000007e9; BYTE $0x00 // jmp LBB23_57, $7(%rip) + +LBB23_2: + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + +LBB23_57: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + LONG $0x18c48348 // addq $24, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB23_65: + LONG $0xf9c5c749; WORD $0xffff; BYTE $0xff // movq $-7, %r13 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB23_57, $-30(%rip) + +LBB23_60: + WORD $0x8b48; BYTE $0x0b // movq (%rbx), %rcx + WORD $0x2948; BYTE $0xc1 // subq %rax, %rcx + LONG $0xfec18348 // addq $-2, %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + +LBB23_61: + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xffffc9e9; BYTE $0xff // jmp LBB23_57, $-55(%rip) + +LBB23_67: + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + LONG $0xffffbae9; BYTE $0xff // jmp LBB23_57, $-70(%rip) + +LBB23_68: + WORD $0xff48; BYTE $0xc8 // decq %rax + +LBB23_56: + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0xffffafe9; BYTE $0xff // jmp LBB23_57, $-81(%rip) + +LBB23_70: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0x03 // addq %rax, (%rbx) + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xffff9de9; BYTE $0xff // jmp LBB23_57, $-99(%rip) + +LBB23_72: + WORD $0xff49; BYTE $0xcd // decq %r13 + LONG $0xffff95e9; BYTE $0xff // jmp LBB23_57, $-107(%rip) + +LBB23_73: + LONG $0xff508d48 // leaq $-1(%rax), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xff017c80; BYTE $0x6e // cmpb $110, $-1(%rcx,%rax) + LONG $0xff7c850f; WORD $0xffff // jne LBB23_57, $-132(%rip) + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0x75013c80 // cmpb $117, (%rcx,%rax) + LONG $0xff6f850f; WORD $0xffff // jne LBB23_57, $-145(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) + LONG $0xff5d850f; WORD $0xffff // jne LBB23_57, $-163(%rip) + LONG $0x02508d48 // leaq $2(%rax), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0x02017c80; BYTE $0x6c // cmpb $108, $2(%rcx,%rax) + LONG $0xff4b850f; WORD $0xffff // jne LBB23_57, $-181(%rip) + LONG $0x00009ce9; BYTE $0x00 // jmp LBB23_86, $156(%rip) + +LBB23_77: + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + WORD $0xfa80; BYTE $0x61 // cmpb $97, %dl + LONG $0xff36850f; WORD $0xffff // jne LBB23_57, $-202(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) + LONG $0xff24850f; WORD $0xffff // jne LBB23_57, $-220(%rip) + LONG $0x02508d48 // leaq $2(%rax), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0x02017c80; BYTE $0x73 // cmpb $115, $2(%rcx,%rax) + LONG $0xff12850f; WORD $0xffff // jne LBB23_57, $-238(%rip) + LONG $0x03508d48 // leaq $3(%rax), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0x03017c80; BYTE $0x65 // cmpb $101, $3(%rcx,%rax) + LONG $0xff00850f; WORD $0xffff // jne LBB23_57, $-256(%rip) + LONG $0x04c08348 // addq $4, %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0xfffef4e9; BYTE $0xff // jmp LBB23_57, $-268(%rip) + +LBB23_82: + LONG $0xff508d48 // leaq $-1(%rax), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xff017c80; BYTE $0x74 // cmpb $116, $-1(%rcx,%rax) + LONG $0xfedb850f; WORD $0xffff // jne LBB23_57, $-293(%rip) + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0x72013c80 // cmpb $114, (%rcx,%rax) + LONG $0xfece850f; WORD $0xffff // jne LBB23_57, $-306(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0x01017c80; BYTE $0x75 // cmpb $117, $1(%rcx,%rax) + LONG $0xfebc850f; WORD $0xffff // jne LBB23_57, $-324(%rip) + LONG $0x02508d48 // leaq $2(%rax), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0x02017c80; BYTE $0x65 // cmpb $101, $2(%rcx,%rax) + LONG $0xfeaa850f; WORD $0xffff // jne LBB23_57, $-342(%rip) + +LBB23_86: + LONG $0x03c08348 // addq $3, %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0xfffe9ee9; BYTE $0xff // jmp LBB23_57, $-354(%rip) + + // .p2align 2, 0x90 + // .set L23_0_set_12, LBB23_12-LJTI23_0 + // .set L23_0_set_15, LBB23_15-LJTI23_0 + // .set L23_0_set_18, LBB23_18-LJTI23_0 + // .set L23_0_set_21, LBB23_21-LJTI23_0 + // .set L23_0_set_23, LBB23_23-LJTI23_0 + // .set L23_0_set_28, LBB23_28-LJTI23_0 +LJTI23_0: + LONG $0xfffffb45 // .long L23_0_set_12 + LONG $0xfffffb7a // .long L23_0_set_15 + LONG $0xfffffbac // .long L23_0_set_18 + LONG $0xfffffbe8 // .long L23_0_set_21 + LONG $0xfffffc00 // .long L23_0_set_23 + LONG $0xfffffc85 // .long L23_0_set_28 + + // .set L23_1_set_57, LBB23_57-LJTI23_1 + // .set L23_1_set_56, LBB23_56-LJTI23_1 + // .set L23_1_set_40, LBB23_40-LJTI23_1 + // .set L23_1_set_42, LBB23_42-LJTI23_1 + // .set L23_1_set_26, LBB23_26-LJTI23_1 + // .set L23_1_set_44, LBB23_44-LJTI23_1 + // .set L23_1_set_45, LBB23_45-LJTI23_1 + // .set L23_1_set_48, LBB23_48-LJTI23_1 + // .set L23_1_set_50, LBB23_50-LJTI23_1 + // .set L23_1_set_3, LBB23_3-LJTI23_1 +LJTI23_1: + LONG $0xfffffe86 // .long L23_1_set_57 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffd48 // .long L23_1_set_40 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffd76 // .long L23_1_set_42 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffc2a // .long L23_1_set_26 + LONG $0xfffffc2a // .long L23_1_set_26 + LONG $0xfffffc2a // .long L23_1_set_26 + LONG $0xfffffc2a // .long L23_1_set_26 + LONG $0xfffffc2a // .long L23_1_set_26 + LONG $0xfffffc2a // .long L23_1_set_26 + LONG $0xfffffc2a // .long L23_1_set_26 + LONG $0xfffffc2a // .long L23_1_set_26 + LONG $0xfffffc2a // .long L23_1_set_26 + LONG $0xfffffc2a // .long L23_1_set_26 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffda5 // .long L23_1_set_44 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffdbf // .long L23_1_set_45 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffdfa // .long L23_1_set_48 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffe24 // .long L23_1_set_50 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffecf // .long L23_1_set_56 + LONG $0xfffffaa4 // .long L23_1_set_3 + QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 + +LCPI24_0: + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000006 // .quad 6 + + // .p2align 4, 0x90 +_skip_object: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI24_0(%rip) */ + LONG $0x0011f8c5 // vmovups %xmm0, (%rax) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0xfff83ee9; BYTE $0xff // jmp _fsm_exec, $-1986(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_skip_string: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + LONG $0x10ec8348 // subq $16, %rsp + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b48; BYTE $0x1e // movq (%rsi), %rbx + LONG $0xe8558d48 // leaq $-24(%rbp), %rdx + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xffeaf0e8; BYTE $0xff // callq _advance_string, $-5392(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0009890f; WORD $0x0000 // jns LBB25_1, $9(%rip) + LONG $0xe84d8b48 // movq $-24(%rbp), %rcx + LONG $0x000009e9; BYTE $0x00 // jmp LBB25_3, $9(%rip) + +LBB25_1: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + +LBB25_3: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +_skip_negative: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b48; BYTE $0x1e // movq (%rsi), %rbx + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0x08778b48 // movq $8(%rdi), %rsi + WORD $0x2948; BYTE $0xde // subq %rbx, %rsi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0x00018ee8; BYTE $0x00 // callq _do_skip_number, $398(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x000b880f; WORD $0x0000 // js LBB26_1, $11(%rip) + WORD $0x0149; BYTE $0x06 // addq %rax, (%r14) + WORD $0xff48; BYTE $0xcb // decq %rbx + LONG $0x00000de9; BYTE $0x00 // jmp LBB26_3, $13(%rip) + +LBB26_1: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0x06 // addq %rax, (%r14) + LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx + +LBB26_3: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x00 // .p2align 5, 0x00 + +LCPI27_0: + QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' + QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' + +LCPI27_1: + QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' + QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' + +LCPI27_2: + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + +LCPI27_3: + QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................' + QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................' + +LCPI27_4: + QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE' + QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE' + +LCPI27_5: + QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0' + QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0' + +LCPI27_6: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + + // .p2align 4, 0x00 +LCPI27_7: + QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' + +LCPI27_8: + QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' + +LCPI27_9: + QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0' + +LCPI27_10: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI27_11: + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + +LCPI27_12: + QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................' + +LCPI27_13: + QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE' + + // .p2align 4, 0x90 +_do_skip_number: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x03a4840f; WORD $0x0000 // je LBB27_1, $932(%rip) + WORD $0x3f80; BYTE $0x30 // cmpb $48, (%rdi) + LONG $0x0033850f; WORD $0x0000 // jne LBB27_6, $51(%rip) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x01fe8348 // cmpq $1, %rsi + LONG $0x04b8840f; WORD $0x0000 // je LBB27_81, $1208(%rip) + LONG $0x014fb60f // movzbl $1(%rdi), %ecx + WORD $0xc183; BYTE $0xd2 // addl $-46, %ecx + WORD $0xf983; BYTE $0x37 // cmpl $55, %ecx + LONG $0x04a8870f; WORD $0x0000 // ja LBB27_81, $1192(%rip) + QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx + LONG $0xcaa30f48 // btq %rcx, %rdx + LONG $0x0494830f; WORD $0x0000 // jae LBB27_81, $1172(%rip) + +LBB27_6: + LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 + LONG $0x20fe8348 // cmpq $32, %rsi + LONG $0x048f820f; WORD $0x0000 // jb LBB27_7, $1167(%rip) + WORD $0xc031 // xorl %eax, %eax + QUAD $0xfffffe45056ffdc5 // vmovdqa $-443(%rip), %ymm0 /* LCPI27_0(%rip) */ + QUAD $0xfffffe5d0d6ffdc5 // vmovdqa $-419(%rip), %ymm1 /* LCPI27_1(%rip) */ + QUAD $0xfffffe75156ffdc5 // vmovdqa $-395(%rip), %ymm2 /* LCPI27_2(%rip) */ + QUAD $0xfffffe8d1d6ffdc5 // vmovdqa $-371(%rip), %ymm3 /* LCPI27_3(%rip) */ + QUAD $0xfffffea5256ffdc5 // vmovdqa $-347(%rip), %ymm4 /* LCPI27_4(%rip) */ + QUAD $0xfffffebd2d6ffdc5 // vmovdqa $-323(%rip), %ymm5 /* LCPI27_5(%rip) */ + QUAD $0xfffffed5356ffdc5 // vmovdqa $-299(%rip), %ymm6 /* LCPI27_6(%rip) */ + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB27_9: + LONG $0x3c6ffec5; BYTE $0x07 // vmovdqu (%rdi,%rax), %ymm7 + LONG $0xc07445c5 // vpcmpeqb %ymm0, %ymm7, %ymm8 + LONG $0xc97445c5 // vpcmpeqb %ymm1, %ymm7, %ymm9 + LONG $0xeb3541c4; BYTE $0xc0 // vpor %ymm8, %ymm9, %ymm8 + LONG $0xcadb45c5 // vpand %ymm2, %ymm7, %ymm9 + LONG $0xcc7435c5 // vpcmpeqb %ymm4, %ymm9, %ymm9 + LONG $0xd37445c5 // vpcmpeqb %ymm3, %ymm7, %ymm10 + LONG $0xd77dc1c4; BYTE $0xd2 // vpmovmskb %ymm10, %edx + LONG $0xd77d41c4; BYTE $0xf9 // vpmovmskb %ymm9, %r15d + LONG $0xd77d41c4; BYTE $0xd8 // vpmovmskb %ymm8, %r11d + LONG $0xfdfcc5c5 // vpaddb %ymm5, %ymm7, %ymm7 + LONG $0xdeda45c5 // vpminub %ymm6, %ymm7, %ymm11 + LONG $0xff74a5c5 // vpcmpeqb %ymm7, %ymm11, %ymm7 + LONG $0xeb2d41c4; BYTE $0xc9 // vpor %ymm9, %ymm10, %ymm9 + LONG $0xffebb5c5 // vpor %ymm7, %ymm9, %ymm7 + LONG $0xffebbdc5 // vpor %ymm7, %ymm8, %ymm7 + LONG $0xcfd7fdc5 // vpmovmskb %ymm7, %ecx + WORD $0xf748; BYTE $0xd1 // notq %rcx + LONG $0xf1bc0f4c // bsfq %rcx, %r14 + LONG $0x20fe8341 // cmpl $32, %r14d + LONG $0x0017840f; WORD $0x0000 // je LBB27_11, $23(%rip) + LONG $0xffffffbb; BYTE $0xff // movl $-1, %ebx + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + WORD $0xe3d3 // shll %cl, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xda21 // andl %ebx, %edx + WORD $0x2141; BYTE $0xdf // andl %ebx, %r15d + WORD $0x2144; BYTE $0xdb // andl %r11d, %ebx + WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d + +LBB27_11: + WORD $0x4a8d; BYTE $0xff // leal $-1(%rdx), %ecx + WORD $0xd121 // andl %edx, %ecx + LONG $0x0384850f; WORD $0x0000 // jne LBB27_12, $900(%rip) + LONG $0xff4f8d41 // leal $-1(%r15), %ecx + WORD $0x2144; BYTE $0xf9 // andl %r15d, %ecx + LONG $0x0377850f; WORD $0x0000 // jne LBB27_12, $887(%rip) + LONG $0xff4b8d41 // leal $-1(%r11), %ecx + WORD $0x2144; BYTE $0xd9 // andl %r11d, %ecx + LONG $0x036a850f; WORD $0x0000 // jne LBB27_12, $874(%rip) + WORD $0xd285 // testl %edx, %edx + LONG $0x0013840f; WORD $0x0000 // je LBB27_19, $19(%rip) + WORD $0xbc0f; BYTE $0xca // bsfl %edx, %ecx + LONG $0xfffa8349 // cmpq $-1, %r10 + LONG $0x035d850f; WORD $0x0000 // jne LBB27_82, $861(%rip) + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + +LBB27_19: + WORD $0x8545; BYTE $0xff // testl %r15d, %r15d + LONG $0x0014840f; WORD $0x0000 // je LBB27_22, $20(%rip) + LONG $0xcfbc0f41 // bsfl %r15d, %ecx + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x0340850f; WORD $0x0000 // jne LBB27_82, $832(%rip) + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 + +LBB27_22: + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x0014840f; WORD $0x0000 // je LBB27_25, $20(%rip) + LONG $0xcbbc0f41 // bsfl %r11d, %ecx + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x0323850f; WORD $0x0000 // jne LBB27_82, $803(%rip) + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x8949; BYTE $0xc9 // movq %rcx, %r9 + +LBB27_25: + LONG $0x20fe8341 // cmpl $32, %r14d + LONG $0x021e850f; WORD $0x0000 // jne LBB27_83, $542(%rip) + LONG $0xe0c68348 // addq $-32, %rsi + LONG $0x20c08348 // addq $32, %rax + LONG $0x1ffe8348 // cmpq $31, %rsi + LONG $0xfef8870f; WORD $0xffff // ja LBB27_9, $-264(%rip) + WORD $0xf8c5; BYTE $0x77 // vzeroupper + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0x014f820f; WORD $0x0000 // jb LBB27_49, $335(%rip) + +LBB27_29: + WORD $0x894d; BYTE $0xf3 // movq %r14, %r11 + WORD $0x2949; BYTE $0xfb // subq %rdi, %r11 + WORD $0xc031 // xorl %eax, %eax + QUAD $0xfffffdb5056f79c5 // vmovdqa $-587(%rip), %xmm8 /* LCPI27_7(%rip) */ + QUAD $0xfffffdbd0d6f79c5 // vmovdqa $-579(%rip), %xmm9 /* LCPI27_8(%rip) */ + QUAD $0xfffffdc5156f79c5 // vmovdqa $-571(%rip), %xmm10 /* LCPI27_9(%rip) */ + QUAD $0xfffffdcd1d6ff9c5 // vmovdqa $-563(%rip), %xmm3 /* LCPI27_10(%rip) */ + QUAD $0xfffffdd5256ff9c5 // vmovdqa $-555(%rip), %xmm4 /* LCPI27_11(%rip) */ + QUAD $0xfffffddd2d6ff9c5 // vmovdqa $-547(%rip), %xmm5 /* LCPI27_12(%rip) */ + QUAD $0xfffffde5356ff9c5 // vmovdqa $-539(%rip), %xmm6 /* LCPI27_13(%rip) */ + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB27_30: + LONG $0x6f7ac1c4; WORD $0x063c // vmovdqu (%r14,%rax), %xmm7 + LONG $0xc774b9c5 // vpcmpeqb %xmm7, %xmm8, %xmm0 + LONG $0xcf74b1c5 // vpcmpeqb %xmm7, %xmm9, %xmm1 + LONG $0xc0ebf1c5 // vpor %xmm0, %xmm1, %xmm0 + LONG $0xcffca9c5 // vpaddb %xmm7, %xmm10, %xmm1 + LONG $0xd3daf1c5 // vpminub %xmm3, %xmm1, %xmm2 + LONG $0xca74f1c5 // vpcmpeqb %xmm2, %xmm1, %xmm1 + LONG $0xd4dbc1c5 // vpand %xmm4, %xmm7, %xmm2 + LONG $0xd674e9c5 // vpcmpeqb %xmm6, %xmm2, %xmm2 + LONG $0xfd74c1c5 // vpcmpeqb %xmm5, %xmm7, %xmm7 + LONG $0xd7d7f9c5 // vpmovmskb %xmm7, %edx + LONG $0xe2d779c5 // vpmovmskb %xmm2, %r12d + LONG $0xf8d779c5 // vpmovmskb %xmm0, %r15d + LONG $0xd7ebe9c5 // vpor %xmm7, %xmm2, %xmm2 + LONG $0xc0ebe9c5 // vpor %xmm0, %xmm2, %xmm0 + LONG $0xc1ebf9c5 // vpor %xmm1, %xmm0, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx + LONG $0x0014840f; WORD $0x0000 // je LBB27_32, $20(%rip) + LONG $0xffffffbb; BYTE $0xff // movl $-1, %ebx + WORD $0xe3d3 // shll %cl, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xda21 // andl %ebx, %edx + WORD $0x2141; BYTE $0xdc // andl %ebx, %r12d + WORD $0x2144; BYTE $0xfb // andl %r15d, %ebx + WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d + +LBB27_32: + WORD $0x5a8d; BYTE $0xff // leal $-1(%rdx), %ebx + WORD $0xd321 // andl %edx, %ebx + LONG $0x0243850f; WORD $0x0000 // jne LBB27_33, $579(%rip) + LONG $0x245c8d41; BYTE $0xff // leal $-1(%r12), %ebx + WORD $0x2144; BYTE $0xe3 // andl %r12d, %ebx + LONG $0x0235850f; WORD $0x0000 // jne LBB27_33, $565(%rip) + LONG $0xff5f8d41 // leal $-1(%r15), %ebx + WORD $0x2144; BYTE $0xfb // andl %r15d, %ebx + LONG $0x0228850f; WORD $0x0000 // jne LBB27_33, $552(%rip) + WORD $0xd285 // testl %edx, %edx + LONG $0x0016840f; WORD $0x0000 // je LBB27_40, $22(%rip) + WORD $0xbc0f; BYTE $0xd2 // bsfl %edx, %edx + LONG $0xfffa8349 // cmpq $-1, %r10 + LONG $0x0223850f; WORD $0x0000 // jne LBB27_84, $547(%rip) + WORD $0x014c; BYTE $0xda // addq %r11, %rdx + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + +LBB27_40: + WORD $0x8545; BYTE $0xe4 // testl %r12d, %r12d + LONG $0x0017840f; WORD $0x0000 // je LBB27_43, $23(%rip) + LONG $0xd4bc0f41 // bsfl %r12d, %edx + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x0203850f; WORD $0x0000 // jne LBB27_84, $515(%rip) + WORD $0x014c; BYTE $0xda // addq %r11, %rdx + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + +LBB27_43: + WORD $0x8545; BYTE $0xff // testl %r15d, %r15d + LONG $0x0017840f; WORD $0x0000 // je LBB27_46, $23(%rip) + LONG $0xd7bc0f41 // bsfl %r15d, %edx + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x01e3850f; WORD $0x0000 // jne LBB27_84, $483(%rip) + WORD $0x014c; BYTE $0xda // addq %r11, %rdx + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + +LBB27_46: + WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx + LONG $0x00dd850f; WORD $0x0000 // jne LBB27_65, $221(%rip) + LONG $0xf0c68348 // addq $-16, %rsi + LONG $0x10c08348 // addq $16, %rax + LONG $0x0ffe8348 // cmpq $15, %rsi + LONG $0xfef9870f; WORD $0xffff // ja LBB27_30, $-263(%rip) + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 + +LBB27_49: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x00c7840f; WORD $0x0000 // je LBB27_67, $199(%rip) + LONG $0x361c8d4d // leaq (%r14,%rsi), %r11 + WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx + WORD $0xc031 // xorl %eax, %eax + LONG $0xda3d8d4c; WORD $0x0001; BYTE $0x00 // leaq $474(%rip), %r15 /* LJTI27_0(%rip) */ + LONG $0x000031e9; BYTE $0x00 // jmp LBB27_51, $49(%rip) + +LBB27_53: + WORD $0xf983; BYTE $0x65 // cmpl $101, %ecx + LONG $0x00a3850f; WORD $0x0000 // jne LBB27_66, $163(%rip) + +LBB27_54: + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x0180850f; WORD $0x0000 // jne LBB27_59, $384(%rip) + LONG $0x02048d4c // leaq (%rdx,%rax), %r8 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB27_63: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x012d840f; WORD $0x0000 // je LBB27_64, $301(%rip) + +LBB27_51: + LONG $0x0cbe0f41; BYTE $0x06 // movsbl (%r14,%rax), %ecx + WORD $0x598d; BYTE $0xd0 // leal $-48(%rcx), %ebx + WORD $0xfb83; BYTE $0x0a // cmpl $10, %ebx + LONG $0xffe3820f; WORD $0xffff // jb LBB27_63, $-29(%rip) + WORD $0x598d; BYTE $0xd5 // leal $-43(%rcx), %ebx + WORD $0xfb83; BYTE $0x1a // cmpl $26, %ebx + LONG $0xffb2870f; WORD $0xffff // ja LBB27_53, $-78(%rip) + LONG $0x9f0c6349 // movslq (%r15,%rbx,4), %rcx + WORD $0x014c; BYTE $0xf9 // addq %r15, %rcx + JMP CX + +LBB27_61: + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x0132850f; WORD $0x0000 // jne LBB27_59, $306(%rip) + LONG $0x020c8d4c // leaq (%rdx,%rax), %r9 + LONG $0xffffbbe9; BYTE $0xff // jmp LBB27_63, $-69(%rip) + +LBB27_57: + LONG $0xfffa8349 // cmpq $-1, %r10 + LONG $0x011f850f; WORD $0x0000 // jne LBB27_59, $287(%rip) + LONG $0x02148d4c // leaq (%rdx,%rax), %r10 + LONG $0xffffa8e9; BYTE $0xff // jmp LBB27_63, $-88(%rip) + +LBB27_1: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0x000120e9; BYTE $0x00 // jmp LBB27_81, $288(%rip) + +LBB27_83: + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 + WORD $0x0149; BYTE $0xfe // addq %rdi, %r14 + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x001d850f; WORD $0x0000 // jne LBB27_68, $29(%rip) + LONG $0x000102e9; BYTE $0x00 // jmp LBB27_81, $258(%rip) + +LBB27_65: + WORD $0xc989 // movl %ecx, %ecx + WORD $0x0149; BYTE $0xce // addq %rcx, %r14 + +LBB27_66: + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 + +LBB27_67: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x00ea840f; WORD $0x0000 // je LBB27_81, $234(%rip) + +LBB27_68: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x00e1840f; WORD $0x0000 // je LBB27_81, $225(%rip) + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x00d8840f; WORD $0x0000 // je LBB27_81, $216(%rip) + WORD $0x2949; BYTE $0xfe // subq %rdi, %r14 + LONG $0xff468d49 // leaq $-1(%r14), %rax + WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 + LONG $0x0033840f; WORD $0x0000 // je LBB27_73, $51(%rip) + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x002a840f; WORD $0x0000 // je LBB27_73, $42(%rip) + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0021840f; WORD $0x0000 // je LBB27_73, $33(%rip) + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x00238e0f; WORD $0x0000 // jle LBB27_77, $35(%rip) + LONG $0xff418d49 // leaq $-1(%r9), %rax + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0016840f; WORD $0x0000 // je LBB27_77, $22(%rip) + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0x000095e9; BYTE $0x00 // jmp LBB27_81, $149(%rip) + +LBB27_73: + WORD $0xf749; BYTE $0xde // negq %r14 + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + LONG $0x00008ae9; BYTE $0x00 // jmp LBB27_81, $138(%rip) + +LBB27_77: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0x094c; BYTE $0xc0 // orq %r8, %rax + WORD $0x990f; BYTE $0xc0 // setns %al + LONG $0x0014880f; WORD $0x0000 // js LBB27_80, $20(%rip) + WORD $0x394d; BYTE $0xc2 // cmpq %r8, %r10 + LONG $0x000b8c0f; WORD $0x0000 // jl LBB27_80, $11(%rip) + WORD $0xf749; BYTE $0xd2 // notq %r10 + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x000067e9; BYTE $0x00 // jmp LBB27_81, $103(%rip) + +LBB27_80: + LONG $0xff488d49 // leaq $-1(%r8), %rcx + WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 + WORD $0xf749; BYTE $0xd0 // notq %r8 + LONG $0xc6450f4d // cmovneq %r14, %r8 + WORD $0xc084 // testb %al, %al + LONG $0xc6440f4d // cmoveq %r14, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x00004be9; BYTE $0x00 // jmp LBB27_81, $75(%rip) + +LBB27_64: + WORD $0x894d; BYTE $0xde // movq %r11, %r14 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xff4e850f; WORD $0xffff // jne LBB27_68, $-178(%rip) + LONG $0x000033e9; BYTE $0x00 // jmp LBB27_81, $51(%rip) + +LBB27_12: + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + LONG $0x000002e9; BYTE $0x00 // jmp LBB27_13, $2(%rip) + +LBB27_82: + WORD $0xc989 // movl %ecx, %ecx + +LBB27_13: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x2948; BYTE $0xc8 // subq %rcx, %rax + LONG $0x00001ee9; BYTE $0x00 // jmp LBB27_81, $30(%rip) + +LBB27_33: + WORD $0xbc0f; BYTE $0xcb // bsfl %ebx, %ecx + LONG $0x00000ae9; BYTE $0x00 // jmp LBB27_34, $10(%rip) + +LBB27_59: + WORD $0x294c; BYTE $0xf7 // subq %r14, %rdi + LONG $0x000008e9; BYTE $0x00 // jmp LBB27_60, $8(%rip) + +LBB27_84: + WORD $0xd189 // movl %edx, %ecx + +LBB27_34: + WORD $0x294c; BYTE $0xf7 // subq %r14, %rdi + WORD $0x2948; BYTE $0xcf // subq %rcx, %rdi + +LBB27_60: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + +LBB27_81: + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB27_7: + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0xfcc0830f; WORD $0xffff // jae LBB27_29, $-832(%rip) + LONG $0xfffe0ae9; BYTE $0xff // jmp LBB27_49, $-502(%rip) + + // .p2align 2, 0x90 + // .set L27_0_set_61, LBB27_61-LJTI27_0 + // .set L27_0_set_66, LBB27_66-LJTI27_0 + // .set L27_0_set_57, LBB27_57-LJTI27_0 + // .set L27_0_set_54, LBB27_54-LJTI27_0 +LJTI27_0: + LONG $0xfffffe82 // .long L27_0_set_61 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffe82 // .long L27_0_set_61 + LONG $0xfffffe95 // .long L27_0_set_57 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffed7 // .long L27_0_set_66 + LONG $0xfffffe34 // .long L27_0_set_54 + LONG $0x90909090 // .p2align 4, 0x90 + +_skip_positive: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b48; BYTE $0x1e // movq (%rsi), %rbx + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0x08778b48 // movq $8(%rdi), %rsi + WORD $0x2948; BYTE $0xde // subq %rbx, %rsi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xfffa5be8; BYTE $0xff // callq _do_skip_number, $-1445(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x000e880f; WORD $0x0000 // js LBB28_1, $14(%rip) + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0x000011e9; BYTE $0x00 // jmp LBB28_3, $17(%rip) + +LBB28_1: + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + WORD $0x2948; BYTE $0xc1 // subq %rax, %rcx + LONG $0xfec18348 // addq $-2, %rcx + LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx + +LBB28_3: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +_skip_number: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b4c; BYTE $0x27 // movq (%rdi), %r12 + LONG $0x08778b48 // movq $8(%rdi), %rsi + WORD $0x8b4d; BYTE $0x3e // movq (%r14), %r15 + WORD $0xc031 // xorl %eax, %eax + LONG $0x3c3c8043; BYTE $0x2d // cmpb $45, (%r12,%r15) + LONG $0x3c1c8d4b // leaq (%r12,%r15), %rbx + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + LONG $0x003c840f; WORD $0x0000 // je LBB29_6, $60(%rip) + WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 + LONG $0x000d830f; WORD $0x0000 // jae LBB29_3, $13(%rip) + WORD $0xb60f; BYTE $0x03 // movzbl (%rbx), %eax + WORD $0xc604 // addb $-58, %al + WORD $0xf63c // cmpb $-10, %al + LONG $0x0038820f; WORD $0x0000 // jb LBB29_8, $56(%rip) + +LBB29_3: + WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi + LONG $0xfff9d0e8; BYTE $0xff // callq _do_skip_number, $-1584(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0021880f; WORD $0x0000 // js LBB29_7, $33(%rip) + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + +LBB29_5: + WORD $0x294c; BYTE $0xe3 // subq %r12, %rbx + WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB29_6: + LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq $-1, %r15 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB29_5, $-30(%rip) + +LBB29_7: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + +LBB29_8: + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + LONG $0xffffd0e9; BYTE $0xff // jmp LBB29_5, $-48(%rip) + LONG $0x00000000 // .p2align 4, 0x00 + +LCPI30_0: + LONG $0x00000001 // .long 1 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + + // .p2align 4, 0x90 +_skip_one: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI30_0(%rip) */ + LONG $0x0011f8c5 // vmovups %xmm0, (%rax) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0xffef8ee9; BYTE $0xff // jmp _fsm_exec, $-4210(%rip) + QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI31_0: + LONG $0x00000001 // .long 1 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + + // .p2align 4, 0x90 +_validate_one: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI31_0(%rip) */ + LONG $0x0011f8c5 // vmovups %xmm0, (%rax) + LONG $0x000020b9; BYTE $0x00 // movl $32, %ecx + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0xffef49e9; BYTE $0xff // jmp _fsm_exec, $-4279(%rip) + QUAD $0x0000000000000000; BYTE $0x00 // .p2align 5, 0x00 + +LCPI32_0: + QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,' + QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,' + +LCPI32_1: + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + +LCPI32_2: + QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]' + QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]' + +LCPI32_6: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI32_7: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI32_8: + QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{' + QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{' + +LCPI32_9: + QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}' + QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}' + +LCPI32_10: + QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[[' + QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[[' + + // .p2align 4, 0x00 +LCPI32_3: + QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,' + +LCPI32_4: + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + +LCPI32_5: + QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]' + + // .p2align 4, 0x90 +_skip_one_fast: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0xe0e48348 // andq $-32, %rsp + LONG $0x80ec8148; WORD $0x0000; BYTE $0x00 // subq $128, %rsp + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0xffdccde8; BYTE $0xff // callq _advance_ns, $-9011(%rip) + WORD $0x8b49; BYTE $0x16 // movq (%r14), %rdx + LONG $0xff628d4c // leaq $-1(%rdx), %r12 + WORD $0xbe0f; BYTE $0xc8 // movsbl %al, %ecx + WORD $0xf983; BYTE $0x7b // cmpl $123, %ecx + LONG $0x0176870f; WORD $0x0000 // ja LBB32_23, $374(%rip) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0x04358d48; WORD $0x0009; BYTE $0x00 // leaq $2308(%rip), %rsi /* LJTI32_0(%rip) */ + LONG $0x8e0c6348 // movslq (%rsi,%rcx,4), %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + JMP CX + +LBB32_2: + WORD $0x8b49; BYTE $0x07 // movq (%r15), %rax + LONG $0x08778b49 // movq $8(%r15), %rsi + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx + LONG $0x20f98348 // cmpq $32, %rcx + LONG $0x082c820f; WORD $0x0000 // jb LBB32_87, $2092(%rip) + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0xf748; BYTE $0xd9 // negq %rcx + QUAD $0xfffffe5e056ffdc5 // vmovdqa $-418(%rip), %ymm0 /* LCPI32_0(%rip) */ + QUAD $0xfffffe760d6ffdc5 // vmovdqa $-394(%rip), %ymm1 /* LCPI32_1(%rip) */ + QUAD $0xfffffe8e156ffdc5 // vmovdqa $-370(%rip), %ymm2 /* LCPI32_2(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB32_4: + LONG $0x1c6ffec5; BYTE $0x10 // vmovdqu (%rax,%rdx), %ymm3 + LONG $0xe074e5c5 // vpcmpeqb %ymm0, %ymm3, %ymm4 + LONG $0xd9dbe5c5 // vpand %ymm1, %ymm3, %ymm3 + LONG $0xda74e5c5 // vpcmpeqb %ymm2, %ymm3, %ymm3 + LONG $0xdcebe5c5 // vpor %ymm4, %ymm3, %ymm3 + LONG $0xfbd7fdc5 // vpmovmskb %ymm3, %edi + WORD $0xff85 // testl %edi, %edi + LONG $0x00ca850f; WORD $0x0000 // jne LBB32_18, $202(%rip) + LONG $0x20c28348 // addq $32, %rdx + LONG $0x0e3c8d48 // leaq (%rsi,%rcx), %rdi + LONG $0xe0c78348 // addq $-32, %rdi + LONG $0xe0c18348 // addq $-32, %rcx + LONG $0x1fff8348 // cmpq $31, %rdi + LONG $0xffc5870f; WORD $0xffff // ja LBB32_4, $-59(%rip) + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x2948; BYTE $0xca // subq %rcx, %rdx + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + LONG $0x10f98348 // cmpq $16, %rcx + LONG $0x0055820f; WORD $0x0000 // jb LBB32_10, $85(%rip) + +LBB32_7: + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi + QUAD $0xfffffee1056ff9c5 // vmovdqa $-287(%rip), %xmm0 /* LCPI32_3(%rip) */ + QUAD $0xfffffee90d6ff9c5 // vmovdqa $-279(%rip), %xmm1 /* LCPI32_4(%rip) */ + QUAD $0xfffffef1156ff9c5 // vmovdqa $-271(%rip), %xmm2 /* LCPI32_5(%rip) */ + BYTE $0x90 // .p2align 4, 0x90 + +LBB32_8: + LONG $0x1a6ffac5 // vmovdqu (%rdx), %xmm3 + LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 + LONG $0xd9dbe1c5 // vpand %xmm1, %xmm3, %xmm3 + LONG $0xda74e1c5 // vpcmpeqb %xmm2, %xmm3, %xmm3 + LONG $0xdcebe1c5 // vpor %xmm4, %xmm3, %xmm3 + LONG $0xfbd7f9c5 // vpmovmskb %xmm3, %edi + WORD $0xff85 // testl %edi, %edi + LONG $0x0744850f; WORD $0x0000 // jne LBB32_86, $1860(%rip) + LONG $0x10c28348 // addq $16, %rdx + LONG $0xf0c18348 // addq $-16, %rcx + LONG $0xf0c68348 // addq $-16, %rsi + LONG $0x0ff98348 // cmpq $15, %rcx + LONG $0xffca870f; WORD $0xffff // ja LBB32_8, $-54(%rip) + +LBB32_10: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0034840f; WORD $0x0000 // je LBB32_17, $52(%rip) + LONG $0x0a3c8d48 // leaq (%rdx,%rcx), %rdi + WORD $0xf631 // xorl %esi, %esi + +LBB32_12: + LONG $0x321cb60f // movzbl (%rdx,%rsi), %ebx + WORD $0xfb83; BYTE $0x2c // cmpl $44, %ebx + LONG $0x0750840f; WORD $0x0000 // je LBB32_88, $1872(%rip) + WORD $0xfb83; BYTE $0x7d // cmpl $125, %ebx + LONG $0x0747840f; WORD $0x0000 // je LBB32_88, $1863(%rip) + WORD $0xfb83; BYTE $0x5d // cmpl $93, %ebx + LONG $0x073e840f; WORD $0x0000 // je LBB32_88, $1854(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx + LONG $0xffd5850f; WORD $0xffff // jne LBB32_12, $-43(%rip) + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + +LBB32_17: + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + LONG $0x0003f3e9; BYTE $0x00 // jmp LBB32_59, $1011(%rip) + +LBB32_18: + WORD $0xbc0f; BYTE $0xc7 // bsfl %edi, %eax + WORD $0x2948; BYTE $0xc8 // subq %rcx, %rax + +LBB32_19: + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + +LBB32_20: + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + +LBB32_21: + LONG $0xd8658d48 // leaq $-40(%rbp), %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB32_22: + LONG $0x03c28348 // addq $3, %rdx + LONG $0x08573b49 // cmpq $8(%r15), %rdx + LONG $0xffe0830f; WORD $0xffff // jae LBB32_21, $-32(%rip) + LONG $0x0003c2e9; BYTE $0x00 // jmp LBB32_59, $962(%rip) + +LBB32_23: + WORD $0x894d; BYTE $0x26 // movq %r12, (%r14) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xffffcce9; BYTE $0xff // jmp LBB32_21, $-52(%rip) + +LBB32_24: + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x08578b4d // movq $8(%r15), %r10 + LONG $0x244c8948; BYTE $0x18 // movq %rcx, $24(%rsp) + LONG $0x110c8d4c // leaq (%rcx,%rdx), %r9 + WORD $0x2949; BYTE $0xd2 // subq %rdx, %r10 + LONG $0x20fa8349 // cmpq $32, %r10 + LONG $0x06aa820f; WORD $0x0000 // jb LBB32_33, $1706(%rip) + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffffd4e056ffdc5 // vmovdqa $-690(%rip), %ymm0 /* LCPI32_6(%rip) */ + QUAD $0xfffffd660d6ffdc5 // vmovdqa $-666(%rip), %ymm1 /* LCPI32_7(%rip) */ + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + LONG $0x00006ae9; BYTE $0x00 // jmp LBB32_26, $106(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB32_29: + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xf921 // andl %edi, %ecx + LONG $0x09048d44 // leal (%rcx,%rcx), %r8d + WORD $0x0945; BYTE $0xf8 // orl %r15d, %r8d + WORD $0x8945; BYTE $0xc5 // movl %r8d, %r13d + WORD $0xf741; BYTE $0xd5 // notl %r13d + WORD $0x2141; BYTE $0xfd // andl %edi, %r13d + LONG $0xaae58141; WORD $0xaaaa; BYTE $0xaa // andl $-1431655766, %r13d + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0x0141; BYTE $0xcd // addl %ecx, %r13d + LONG $0xc7920f41 // setb %r15b + WORD $0x0145; BYTE $0xed // addl %r13d, %r13d + LONG $0x55f58141; WORD $0x5555; BYTE $0x55 // xorl $1431655765, %r13d + WORD $0x2145; BYTE $0xc5 // andl %r8d, %r13d + WORD $0xf741; BYTE $0xd5 // notl %r13d + WORD $0x2145; BYTE $0xeb // andl %r13d, %r11d + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x004d850f; WORD $0x0000 // jne LBB32_85, $77(%rip) + +LBB32_30: + LONG $0x20c38348 // addq $32, %rbx + LONG $0x320c8d49 // leaq (%r10,%rsi), %rcx + LONG $0xe0c18348 // addq $-32, %rcx + LONG $0xe0c68348 // addq $-32, %rsi + LONG $0x1ff98348 // cmpq $31, %rcx + LONG $0x0615860f; WORD $0x0000 // jbe LBB32_31, $1557(%rip) + +LBB32_26: + LONG $0x6f7ec1c4; WORD $0x1914 // vmovdqu (%r9,%rbx), %ymm2 + LONG $0xd874edc5 // vpcmpeqb %ymm0, %ymm2, %ymm3 + LONG $0xdbd77dc5 // vpmovmskb %ymm3, %r11d + LONG $0xd174edc5 // vpcmpeqb %ymm1, %ymm2, %ymm2 + LONG $0xfad7fdc5 // vpmovmskb %ymm2, %edi + WORD $0xff85 // testl %edi, %edi + LONG $0xff84850f; WORD $0xffff // jne LBB32_29, $-124(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xff7b850f; WORD $0xffff // jne LBB32_29, $-133(%rip) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0xffb3840f; WORD $0xffff // je LBB32_30, $-77(%rip) + +LBB32_85: + LONG $0xc3bc0f41 // bsfl %r11d, %eax + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xfffedee9; BYTE $0xff // jmp LBB32_19, $-290(%rip) + +LBB32_34: + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx + WORD $0x0349; BYTE $0x17 // addq (%r15), %rdx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + QUAD $0xfffffc98056ffdc5 // vmovdqa $-872(%rip), %ymm0 /* LCPI32_7(%rip) */ + QUAD $0xfffffc700d6ffdc5 // vmovdqa $-912(%rip), %ymm1 /* LCPI32_6(%rip) */ + LONG $0xd276e9c5 // vpcmpeqd %xmm2, %xmm2, %xmm2 + QUAD $0xfffffce41d6ffdc5 // vmovdqa $-796(%rip), %ymm3 /* LCPI32_10(%rip) */ + QUAD $0xfffffc3c256ffdc5 // vmovdqa $-964(%rip), %ymm4 /* LCPI32_2(%rip) */ + LONG $0x573041c4; BYTE $0xc9 // vxorps %xmm9, %xmm9, %xmm9 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0xf631 // xorl %esi, %esi + LONG $0x00001ce9; BYTE $0x00 // jmp LBB32_36, $28(%rip) + +LBB32_35: + LONG $0x3ffdc149 // sarq $63, %r13 + LONG $0xb80f49f3; BYTE $0xc8 // popcntq %r8, %rcx + WORD $0x0149; BYTE $0xcb // addq %rcx, %r11 + LONG $0x40c28348 // addq $64, %rdx + LONG $0x244c8b48; BYTE $0x18 // movq $24(%rsp), %rcx + LONG $0xc0c18348 // addq $-64, %rcx + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + +LBB32_36: + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0x244c8948; BYTE $0x18 // movq %rcx, $24(%rsp) + LONG $0x012b8c0f; WORD $0x0000 // jl LBB32_43, $299(%rip) + +LBB32_37: + LONG $0x3a6ffec5 // vmovdqu (%rdx), %ymm7 + LONG $0x726ffec5; BYTE $0x20 // vmovdqu $32(%rdx), %ymm6 + LONG $0xc07445c5 // vpcmpeqb %ymm0, %ymm7, %ymm8 + LONG $0xd77dc1c4; BYTE $0xc8 // vpmovmskb %ymm8, %ecx + LONG $0xc0744dc5 // vpcmpeqb %ymm0, %ymm6, %ymm8 + LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x094c; BYTE $0xd7 // orq %r10, %rdi + LONG $0x000f850f; WORD $0x0000 // jne LBB32_39, $15(%rip) + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x000046e9; BYTE $0x00 // jmp LBB32_40, $70(%rip) + +LBB32_39: + WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + LONG $0x3f2c8d4c // leaq (%rdi,%rdi), %r13 + WORD $0x094d; BYTE $0xd5 // orq %r10, %r13 + WORD $0x894d; BYTE $0xe8 // movq %r13, %r8 + WORD $0xf749; BYTE $0xd0 // notq %r8 + QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx + WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx + WORD $0x214c; BYTE $0xc1 // andq %r8, %rcx + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x0148; BYTE $0xf9 // addq %rdi, %rcx + LONG $0xc2920f41 // setb %r10b + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + QUAD $0x555555555555bf48; WORD $0x5555 // movabsq $6148914691236517205, %rdi + WORD $0x3148; BYTE $0xf9 // xorq %rdi, %rcx + WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + +LBB32_40: + LONG $0xc1744dc5 // vpcmpeqb %ymm1, %ymm6, %ymm8 + LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi + LONG $0x20e7c148 // shlq $32, %rdi + LONG $0xc17445c5 // vpcmpeqb %ymm1, %ymm7, %ymm8 + LONG $0xd77dc1c4; BYTE $0xd8 // vpmovmskb %ymm8, %ebx + WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx + WORD $0x2148; BYTE $0xcb // andq %rcx, %rbx + LONG $0x6ef9e1c4; BYTE $0xeb // vmovq %rbx, %xmm5 + LONG $0x4451e3c4; WORD $0x00ea // vpclmulqdq $0, %xmm2, %xmm5, %xmm5 + LONG $0x7ef9c1c4; BYTE $0xed // vmovq %xmm5, %r13 + WORD $0x314d; BYTE $0xcd // xorq %r9, %r13 + LONG $0xeb74c5c5 // vpcmpeqb %ymm3, %ymm7, %ymm5 + LONG $0xc5d77dc5 // vpmovmskb %ymm5, %r8d + LONG $0xeb74cdc5 // vpcmpeqb %ymm3, %ymm6, %ymm5 + LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0949; BYTE $0xf8 // orq %rdi, %r8 + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x214d; BYTE $0xc8 // andq %r9, %r8 + LONG $0xec74c5c5 // vpcmpeqb %ymm4, %ymm7, %ymm5 + LONG $0xddd7fdc5 // vpmovmskb %ymm5, %ebx + LONG $0xec74cdc5 // vpcmpeqb %ymm4, %ymm6, %ymm5 + LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx + WORD $0x214c; BYTE $0xcb // andq %r9, %rbx + LONG $0xfee3840f; WORD $0xffff // je LBB32_35, $-285(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB32_41: + LONG $0xff4b8d48 // leaq $-1(%rbx), %rcx + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x214c; BYTE $0xc7 // andq %r8, %rdi + LONG $0xb80f48f3; BYTE $0xff // popcntq %rdi, %rdi + WORD $0x014c; BYTE $0xdf // addq %r11, %rdi + WORD $0x3948; BYTE $0xf7 // cmpq %rsi, %rdi + LONG $0x0405860f; WORD $0x0000 // jbe LBB32_84, $1029(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x2148; BYTE $0xcb // andq %rcx, %rbx + LONG $0xffd9850f; WORD $0xffff // jne LBB32_41, $-39(%rip) + LONG $0xfffeaae9; BYTE $0xff // jmp LBB32_35, $-342(%rip) + +LBB32_43: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x04688e0f; WORD $0x0000 // jle LBB32_89, $1128(%rip) + LONG $0x4c297cc5; WORD $0x4024 // vmovaps %ymm9, $64(%rsp) + LONG $0x4c297cc5; WORD $0x2024 // vmovaps %ymm9, $32(%rsp) + WORD $0xd189 // movl %edx, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx + LONG $0xfeac820f; WORD $0xffff // jb LBB32_37, $-340(%rip) + LONG $0x247c8348; WORD $0x2018 // cmpq $32, $24(%rsp) + LONG $0x0021820f; WORD $0x0000 // jb LBB32_47, $33(%rip) + LONG $0x2a10fcc5 // vmovups (%rdx), %ymm5 + LONG $0x6c29fcc5; WORD $0x2024 // vmovaps %ymm5, $32(%rsp) + LONG $0x20c28348 // addq $32, %rdx + LONG $0x244c8b48; BYTE $0x18 // movq $24(%rsp), %rcx + LONG $0xe0598d48 // leaq $-32(%rcx), %rbx + LONG $0x247c8d48; BYTE $0x40 // leaq $64(%rsp), %rdi + LONG $0x00000ae9; BYTE $0x00 // jmp LBB32_48, $10(%rip) + +LBB32_47: + LONG $0x247c8d48; BYTE $0x20 // leaq $32(%rsp), %rdi + LONG $0x245c8b48; BYTE $0x18 // movq $24(%rsp), %rbx + +LBB32_48: + LONG $0x10fb8348 // cmpq $16, %rbx + LONG $0x0058820f; WORD $0x0000 // jb LBB32_49, $88(%rip) + LONG $0x2a10f8c5 // vmovups (%rdx), %xmm5 + LONG $0x2f11f8c5 // vmovups %xmm5, (%rdi) + LONG $0x10c28348 // addq $16, %rdx + LONG $0x10c78348 // addq $16, %rdi + LONG $0xf0c38348 // addq $-16, %rbx + LONG $0x08fb8348 // cmpq $8, %rbx + LONG $0x0044830f; WORD $0x0000 // jae LBB32_54, $68(%rip) + +LBB32_50: + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x0056820f; WORD $0x0000 // jb LBB32_51, $86(%rip) + +LBB32_55: + WORD $0x0a8b // movl (%rdx), %ecx + WORD $0x0f89 // movl %ecx, (%rdi) + LONG $0x04c28348 // addq $4, %rdx + LONG $0x04c78348 // addq $4, %rdi + LONG $0xfcc38348 // addq $-4, %rbx + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0046830f; WORD $0x0000 // jae LBB32_56, $70(%rip) + +LBB32_52: + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0058850f; WORD $0x0000 // jne LBB32_57, $88(%rip) + LONG $0xfffe13e9; BYTE $0xff // jmp LBB32_37, $-493(%rip) + +LBB32_49: + LONG $0x08fb8348 // cmpq $8, %rbx + LONG $0xffbc820f; WORD $0xffff // jb LBB32_50, $-68(%rip) + +LBB32_54: + WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x08c28348 // addq $8, %rdx + LONG $0x08c78348 // addq $8, %rdi + LONG $0xf8c38348 // addq $-8, %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0xffaa830f; WORD $0xffff // jae LBB32_55, $-86(%rip) + +LBB32_51: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0xffba820f; WORD $0xffff // jb LBB32_52, $-70(%rip) + +LBB32_56: + WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx + WORD $0x8966; BYTE $0x0f // movw %cx, (%rdi) + LONG $0x02c28348 // addq $2, %rdx + LONG $0x02c78348 // addq $2, %rdi + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xfdc0840f; WORD $0xffff // je LBB32_37, $-576(%rip) + +LBB32_57: + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + WORD $0x0f88 // movb %cl, (%rdi) + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + LONG $0xfffdb1e9; BYTE $0xff // jmp LBB32_37, $-591(%rip) + +LBB32_58: + LONG $0x04c28348 // addq $4, %rdx + LONG $0x08573b49 // cmpq $8(%r15), %rdx + LONG $0xfc19830f; WORD $0xffff // jae LBB32_21, $-999(%rip) + +LBB32_59: + WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) + LONG $0xfffc0ee9; BYTE $0xff // jmp LBB32_20, $-1010(%rip) + +LBB32_60: + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx + WORD $0x0349; BYTE $0x17 // addq (%r15), %rdx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + QUAD $0xfffff9c5056ffdc5 // vmovdqa $-1595(%rip), %ymm0 /* LCPI32_7(%rip) */ + QUAD $0xfffff99d0d6ffdc5 // vmovdqa $-1635(%rip), %ymm1 /* LCPI32_6(%rip) */ + LONG $0xd276e9c5 // vpcmpeqd %xmm2, %xmm2, %xmm2 + QUAD $0xfffff9d11d6ffdc5 // vmovdqa $-1583(%rip), %ymm3 /* LCPI32_8(%rip) */ + QUAD $0xfffff9e9256ffdc5 // vmovdqa $-1559(%rip), %ymm4 /* LCPI32_9(%rip) */ + LONG $0x573041c4; BYTE $0xc9 // vxorps %xmm9, %xmm9, %xmm9 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0xf631 // xorl %esi, %esi + LONG $0x00001ce9; BYTE $0x00 // jmp LBB32_62, $28(%rip) + +LBB32_61: + LONG $0x3ffdc149 // sarq $63, %r13 + LONG $0xb80f49f3; BYTE $0xc8 // popcntq %r8, %rcx + WORD $0x0149; BYTE $0xcb // addq %rcx, %r11 + LONG $0x40c28348 // addq $64, %rdx + LONG $0x244c8b48; BYTE $0x18 // movq $24(%rsp), %rcx + LONG $0xc0c18348 // addq $-64, %rcx + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + +LBB32_62: + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0x244c8948; BYTE $0x18 // movq %rcx, $24(%rsp) + LONG $0x01288c0f; WORD $0x0000 // jl LBB32_69, $296(%rip) + +LBB32_63: + LONG $0x3a6ffec5 // vmovdqu (%rdx), %ymm7 + LONG $0x726ffec5; BYTE $0x20 // vmovdqu $32(%rdx), %ymm6 + LONG $0xc07445c5 // vpcmpeqb %ymm0, %ymm7, %ymm8 + LONG $0xd77dc1c4; BYTE $0xc8 // vpmovmskb %ymm8, %ecx + LONG $0xc0744dc5 // vpcmpeqb %ymm0, %ymm6, %ymm8 + LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x094c; BYTE $0xd7 // orq %r10, %rdi + LONG $0x000f850f; WORD $0x0000 // jne LBB32_65, $15(%rip) + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x000046e9; BYTE $0x00 // jmp LBB32_66, $70(%rip) + +LBB32_65: + WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + LONG $0x3f2c8d4c // leaq (%rdi,%rdi), %r13 + WORD $0x094d; BYTE $0xd5 // orq %r10, %r13 + WORD $0x894d; BYTE $0xe8 // movq %r13, %r8 + WORD $0xf749; BYTE $0xd0 // notq %r8 + QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx + WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx + WORD $0x214c; BYTE $0xc1 // andq %r8, %rcx + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x0148; BYTE $0xf9 // addq %rdi, %rcx + LONG $0xc2920f41 // setb %r10b + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + QUAD $0x555555555555bf48; WORD $0x5555 // movabsq $6148914691236517205, %rdi + WORD $0x3148; BYTE $0xf9 // xorq %rdi, %rcx + WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + +LBB32_66: + LONG $0xc1744dc5 // vpcmpeqb %ymm1, %ymm6, %ymm8 + LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi + LONG $0x20e7c148 // shlq $32, %rdi + LONG $0xc17445c5 // vpcmpeqb %ymm1, %ymm7, %ymm8 + LONG $0xd77dc1c4; BYTE $0xd8 // vpmovmskb %ymm8, %ebx + WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx + WORD $0x2148; BYTE $0xcb // andq %rcx, %rbx + LONG $0x6ef9e1c4; BYTE $0xeb // vmovq %rbx, %xmm5 + LONG $0x4451e3c4; WORD $0x00ea // vpclmulqdq $0, %xmm2, %xmm5, %xmm5 + LONG $0x7ef9c1c4; BYTE $0xed // vmovq %xmm5, %r13 + WORD $0x314d; BYTE $0xcd // xorq %r9, %r13 + LONG $0xeb74c5c5 // vpcmpeqb %ymm3, %ymm7, %ymm5 + LONG $0xc5d77dc5 // vpmovmskb %ymm5, %r8d + LONG $0xeb74cdc5 // vpcmpeqb %ymm3, %ymm6, %ymm5 + LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0949; BYTE $0xf8 // orq %rdi, %r8 + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x214d; BYTE $0xc8 // andq %r9, %r8 + LONG $0xec74c5c5 // vpcmpeqb %ymm4, %ymm7, %ymm5 + LONG $0xddd7fdc5 // vpmovmskb %ymm5, %ebx + LONG $0xec74cdc5 // vpcmpeqb %ymm4, %ymm6, %ymm5 + LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx + WORD $0x214c; BYTE $0xcb // andq %r9, %rbx + LONG $0xfee3840f; WORD $0xffff // je LBB32_61, $-285(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB32_67: + LONG $0xff4b8d48 // leaq $-1(%rbx), %rcx + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x214c; BYTE $0xc7 // andq %r8, %rdi + LONG $0xb80f48f3; BYTE $0xff // popcntq %rdi, %rdi + WORD $0x014c; BYTE $0xdf // addq %r11, %rdi + WORD $0x3948; BYTE $0xf7 // cmpq %rsi, %rdi + LONG $0x0135860f; WORD $0x0000 // jbe LBB32_84, $309(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x2148; BYTE $0xcb // andq %rcx, %rbx + LONG $0xffd9850f; WORD $0xffff // jne LBB32_67, $-39(%rip) + LONG $0xfffeade9; BYTE $0xff // jmp LBB32_61, $-339(%rip) + +LBB32_69: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x01988e0f; WORD $0x0000 // jle LBB32_89, $408(%rip) + LONG $0x4c297cc5; WORD $0x4024 // vmovaps %ymm9, $64(%rsp) + LONG $0x4c297cc5; WORD $0x2024 // vmovaps %ymm9, $32(%rsp) + WORD $0xd189 // movl %edx, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx + LONG $0xfeaf820f; WORD $0xffff // jb LBB32_63, $-337(%rip) + LONG $0x247c8348; WORD $0x2018 // cmpq $32, $24(%rsp) + LONG $0x0021820f; WORD $0x0000 // jb LBB32_73, $33(%rip) + LONG $0x2a10fcc5 // vmovups (%rdx), %ymm5 + LONG $0x6c29fcc5; WORD $0x2024 // vmovaps %ymm5, $32(%rsp) + LONG $0x20c28348 // addq $32, %rdx + LONG $0x244c8b48; BYTE $0x18 // movq $24(%rsp), %rcx + LONG $0xe0598d48 // leaq $-32(%rcx), %rbx + LONG $0x247c8d48; BYTE $0x40 // leaq $64(%rsp), %rdi + LONG $0x00000ae9; BYTE $0x00 // jmp LBB32_74, $10(%rip) + +LBB32_73: + LONG $0x247c8d48; BYTE $0x20 // leaq $32(%rsp), %rdi + LONG $0x245c8b48; BYTE $0x18 // movq $24(%rsp), %rbx + +LBB32_74: + LONG $0x10fb8348 // cmpq $16, %rbx + LONG $0x0058820f; WORD $0x0000 // jb LBB32_75, $88(%rip) + LONG $0x2a10f8c5 // vmovups (%rdx), %xmm5 + LONG $0x2f11f8c5 // vmovups %xmm5, (%rdi) + LONG $0x10c28348 // addq $16, %rdx + LONG $0x10c78348 // addq $16, %rdi + LONG $0xf0c38348 // addq $-16, %rbx + LONG $0x08fb8348 // cmpq $8, %rbx + LONG $0x0044830f; WORD $0x0000 // jae LBB32_80, $68(%rip) + +LBB32_76: + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x0056820f; WORD $0x0000 // jb LBB32_77, $86(%rip) + +LBB32_81: + WORD $0x0a8b // movl (%rdx), %ecx + WORD $0x0f89 // movl %ecx, (%rdi) + LONG $0x04c28348 // addq $4, %rdx + LONG $0x04c78348 // addq $4, %rdi + LONG $0xfcc38348 // addq $-4, %rbx + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0046830f; WORD $0x0000 // jae LBB32_82, $70(%rip) + +LBB32_78: + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0058850f; WORD $0x0000 // jne LBB32_83, $88(%rip) + LONG $0xfffe16e9; BYTE $0xff // jmp LBB32_63, $-490(%rip) + +LBB32_75: + LONG $0x08fb8348 // cmpq $8, %rbx + LONG $0xffbc820f; WORD $0xffff // jb LBB32_76, $-68(%rip) + +LBB32_80: + WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x08c28348 // addq $8, %rdx + LONG $0x08c78348 // addq $8, %rdi + LONG $0xf8c38348 // addq $-8, %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0xffaa830f; WORD $0xffff // jae LBB32_81, $-86(%rip) + +LBB32_77: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0xffba820f; WORD $0xffff // jb LBB32_78, $-70(%rip) + +LBB32_82: + WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx + WORD $0x8966; BYTE $0x0f // movw %cx, (%rdi) + LONG $0x02c28348 // addq $2, %rdx + LONG $0x02c78348 // addq $2, %rdi + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xfdc3840f; WORD $0xffff // je LBB32_63, $-573(%rip) + +LBB32_83: + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + WORD $0x0f88 // movb %cl, (%rdi) + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + LONG $0xfffdb4e9; BYTE $0xff // jmp LBB32_63, $-588(%rip) + +LBB32_84: + LONG $0x08478b49 // movq $8(%r15), %rax + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + LONG $0x244c2b48; BYTE $0x18 // subq $24(%rsp), %rcx + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0xc8420f48 // cmovbq %rax, %rcx + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xe0470f4c // cmovaq %rax, %r12 + LONG $0xfff920e9; BYTE $0xff // jmp LBB32_20, $-1760(%rip) + +LBB32_86: + LONG $0xc7bc0f66 // bsfw %di, %ax + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax + LONG $0xfff90ee9; BYTE $0xff // jmp LBB32_19, $-1778(%rip) + +LBB32_31: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x003d850f; WORD $0x0000 // jne LBB32_90, $61(%rip) + WORD $0x0149; BYTE $0xd9 // addq %rbx, %r9 + WORD $0x0149; BYTE $0xf2 // addq %rsi, %r10 + +LBB32_33: + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0070850f; WORD $0x0000 // jne LBB32_94, $112(%rip) + LONG $0xfff8f7e9; BYTE $0xff // jmp LBB32_21, $-1801(%rip) + +LBB32_87: + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0x10f98348 // cmpq $16, %rcx + LONG $0xf844830f; WORD $0xffff // jae LBB32_7, $-1980(%rip) + LONG $0xfff894e9; BYTE $0xff // jmp LBB32_10, $-1900(%rip) + +LBB32_88: + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + WORD $0x0148; BYTE $0xf2 // addq %rsi, %rdx + LONG $0xfffcc1e9; BYTE $0xff // jmp LBB32_59, $-831(%rip) + +LBB32_89: + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0xfff8cee9; BYTE $0xff // jmp LBB32_21, $-1842(%rip) + +LBB32_90: + WORD $0x3949; BYTE $0xda // cmpq %rbx, %r10 + LONG $0xf8c5840f; WORD $0xffff // je LBB32_21, $-1851(%rip) + WORD $0x0149; BYTE $0xd9 // addq %rbx, %r9 + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0xf748; BYTE $0xd3 // notq %rbx + WORD $0x0149; BYTE $0xda // addq %rbx, %r10 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0024850f; WORD $0x0000 // jne LBB32_94, $36(%rip) + LONG $0xfff8abe9; BYTE $0xff // jmp LBB32_21, $-1877(%rip) + +LBB32_92: + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x0149; BYTE $0xca // addq %rcx, %r10 + LONG $0xf88c840f; WORD $0xffff // je LBB32_21, $-1908(%rip) + +LBB32_94: + LONG $0x01b60f41 // movzbl (%r9), %eax + WORD $0xf883; BYTE $0x5c // cmpl $92, %eax + LONG $0xffd4840f; WORD $0xffff // je LBB32_92, $-44(%rip) + WORD $0xf883; BYTE $0x22 // cmpl $34, %eax + LONG $0x0024840f; WORD $0x0000 // je LBB32_97, $36(%rip) + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x0149; BYTE $0xca // addq %rcx, %r10 + LONG $0xffcb850f; WORD $0xffff // jne LBB32_94, $-53(%rip) + LONG $0xfff852e9; BYTE $0xff // jmp LBB32_21, $-1966(%rip) + +LBB32_97: + LONG $0x244c2b4c; BYTE $0x18 // subq $24(%rsp), %r9 + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0x894d; BYTE $0x0e // movq %r9, (%r14) + LONG $0xfff83fe9; BYTE $0xff // jmp LBB32_20, $-1985(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90 + + // .set L32_0_set_21, LBB32_21-LJTI32_0 + // .set L32_0_set_23, LBB32_23-LJTI32_0 + // .set L32_0_set_24, LBB32_24-LJTI32_0 + // .set L32_0_set_2, LBB32_2-LJTI32_0 + // .set L32_0_set_34, LBB32_34-LJTI32_0 + // .set L32_0_set_58, LBB32_58-LJTI32_0 + // .set L32_0_set_22, LBB32_22-LJTI32_0 + // .set L32_0_set_60, LBB32_60-LJTI32_0 +LJTI32_0: + LONG $0xfffff83f // .long L32_0_set_21 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff873 // .long L32_0_set_24 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff705 // .long L32_0_set_2 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff95b // .long L32_0_set_34 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffffc18 // .long L32_0_set_58 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff851 // .long L32_0_set_22 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff851 // .long L32_0_set_22 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffff864 // .long L32_0_set_23 + LONG $0xfffffc2e // .long L32_0_set_60 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +_get_by_path: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x38ec8348 // subq $56, %rsp + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0x08428b48 // movq $8(%rdx), %rax + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x041d840f; WORD $0x0000 // je LBB33_67, $1053(%rip) + WORD $0x8b4c; BYTE $0x22 // movq (%rdx), %r12 + LONG $0x04e0c148 // shlq $4, %rax + WORD $0x014c; BYTE $0xe0 // addq %r12, %rax + LONG $0xa0458948 // movq %rax, $-96(%rbp) + +LBB33_2: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0xffd173e8; BYTE $0xff // callq _advance_ns, $-11917(%rip) + LONG $0x240c8b49 // movq (%r12), %rcx + LONG $0x1749b60f // movzbl $23(%rcx), %ecx + WORD $0xe180; BYTE $0x1f // andb $31, %cl + WORD $0xf980; BYTE $0x18 // cmpb $24, %cl + LONG $0x038f850f; WORD $0x0000 // jne LBB33_61, $911(%rip) + WORD $0x7b3c // cmpb $123, %al + LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0xb865894c // movq %r12, $-72(%rbp) + LONG $0x03f0850f; WORD $0x0000 // jne LBB33_68, $1008(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_4: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0xffd135e8; BYTE $0xff // callq _advance_ns, $-11979(%rip) + WORD $0x223c // cmpb $34, %al + LONG $0x03ce850f; WORD $0x0000 // jne LBB33_68, $974(%rip) + LONG $0x24448b49; BYTE $0x08 // movq $8(%r12), %rax + WORD $0x8b4c; BYTE $0x28 // movq (%rax), %r13 + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x08788b4c // movq $8(%rax), %r15 + QUAD $0xffffffffb045c748 // movq $-1, $-80(%rbp) + WORD $0x8b4d; BYTE $0x26 // movq (%r14), %r12 + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0xb0558d48 // leaq $-80(%rbp), %rdx + LONG $0x002647e8; BYTE $0x00 // callq _advance_string_default, $9799(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x03b8880f; WORD $0x0000 // js LBB33_70, $952(%rip) + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0xb04d8b48 // movq $-80(%rbp), %rcx + LONG $0xfff98348 // cmpq $-1, %rcx + LONG $0x0009840f; WORD $0x0000 // je LBB33_8, $9(%rip) + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x02018e0f; WORD $0x0000 // jle LBB33_37, $513(%rip) + +LBB33_8: + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax + LONG $0x0062850f; WORD $0x0000 // jne LBB33_13, $98(%rip) + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x034c; BYTE $0x20 // addq (%rax), %r12 + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + WORD $0x894c; BYTE $0xea // movq %r13, %rdx + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB33_10: + LONG $0x20f88348 // cmpq $32, %rax + LONG $0x0046820f; WORD $0x0000 // jb LBB33_14, $70(%rip) + LONG $0x066ffec5 // vmovdqu (%rsi), %ymm0 + LONG $0x02f8fdc5 // vpsubb (%rdx), %ymm0, %ymm0 + LONG $0x20c68348 // addq $32, %rsi + LONG $0x20c28348 // addq $32, %rdx + LONG $0xe0c08348 // addq $-32, %rax + LONG $0x20c78348 // addq $32, %rdi + LONG $0x20c38348 // addq $32, %rbx + LONG $0x20c18348 // addq $32, %rcx + LONG $0x177de2c4; BYTE $0xc0 // vptest %ymm0, %ymm0 + LONG $0xffcb840f; WORD $0xffff // je LBB33_10, $-53(%rip) + LONG $0x000090e9; BYTE $0x00 // jmp LBB33_12, $144(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB33_13: + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x00013ce9; BYTE $0x00 // jmp LBB33_33, $316(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_14: + LONG $0x0fffe381; WORD $0x0000 // andl $4095, %ebx + LONG $0x0fe0fb81; WORD $0x0000 // cmpl $4064, %ebx + LONG $0x003e870f; WORD $0x0000 // ja LBB33_18, $62(%rip) + LONG $0x0fffe781; WORD $0x0000 // andl $4095, %edi + LONG $0x0fe1ff81; WORD $0x0000 // cmpl $4065, %edi + LONG $0x002c830f; WORD $0x0000 // jae LBB33_18, $44(%rip) + LONG $0x066ffec5 // vmovdqu (%rsi), %ymm0 + LONG $0x0274fdc5 // vpcmpeqb (%rdx), %ymm0, %ymm0 + LONG $0xc8d7fdc5 // vpmovmskb %ymm0, %ecx + WORD $0xf983; BYTE $0xff // cmpl $-1, %ecx + LONG $0x00ad840f; WORD $0x0000 // je LBB33_31, $173(%rip) + WORD $0xd1f7 // notl %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + LONG $0x000098e9; BYTE $0x00 // jmp LBB33_25, $152(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_18: + LONG $0x10f88348 // cmpq $16, %rax + LONG $0x0027820f; WORD $0x0000 // jb LBB33_21, $39(%rip) + LONG $0x6f7ac1c4; WORD $0x0c04 // vmovdqu (%r12,%rcx), %xmm0 + LONG $0xf879c1c4; WORD $0x0d44; BYTE $0x00 // vpsubb (%r13,%rcx), %xmm0, %xmm0 + LONG $0xf0c08348 // addq $-16, %rax + LONG $0x10c18348 // addq $16, %rcx + LONG $0x1779e2c4; BYTE $0xc0 // vptest %xmm0, %xmm0 + LONG $0xffd6840f; WORD $0xffff // je LBB33_18, $-42(%rip) + +LBB33_12: + WORD $0xc031 // xorl %eax, %eax + LONG $0x0000afe9; BYTE $0x00 // jmp LBB33_32, $175(%rip) + +LBB33_21: + WORD $0x8944; BYTE $0xe2 // movl %r12d, %edx + WORD $0xca01 // addl %ecx, %edx + LONG $0x0fffe281; WORD $0x0000 // andl $4095, %edx + LONG $0x0ff0fa81; WORD $0x0000 // cmpl $4080, %edx + LONG $0x0055870f; WORD $0x0000 // ja LBB33_27, $85(%rip) + LONG $0x29148d42 // leal (%rcx,%r13), %edx + LONG $0x0fffe281; WORD $0x0000 // andl $4095, %edx + LONG $0x0ff1fa81; WORD $0x0000 // cmpl $4081, %edx + LONG $0x003f830f; WORD $0x0000 // jae LBB33_27, $63(%rip) + LONG $0x6f7ac1c4; WORD $0x0c04 // vmovdqu (%r12,%rcx), %xmm0 + LONG $0x6f7ac1c4; WORD $0x0d4c; BYTE $0x00 // vmovdqu (%r13,%rcx), %xmm1 + LONG $0xd1f8f9c5 // vpsubb %xmm1, %xmm0, %xmm2 + LONG $0x1779e2c4; BYTE $0xd2 // vptest %xmm2, %xmm2 + LONG $0x001c840f; WORD $0x0000 // je LBB33_31, $28(%rip) + LONG $0xc174f9c5 // vpcmpeqb %xmm1, %xmm0, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0xc9bc0f66 // bsfw %cx, %cx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + +LBB33_25: + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + WORD $0x960f; BYTE $0xc0 // setbe %al + LONG $0x00004ae9; BYTE $0x00 // jmp LBB33_32, $74(%rip) + +LBB33_31: + WORD $0x01b0 // movb $1, %al + LONG $0x000043e9; BYTE $0x00 // jmp LBB33_32, $67(%rip) + +LBB33_27: + WORD $0x01b0 // movb $1, %al + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x0038840f; WORD $0x0000 // je LBB33_32, $56(%rip) + WORD $0xff49; BYTE $0xcf // decq %r15 + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_29: + LONG $0x04b60f41; BYTE $0x0c // movzbl (%r12,%rcx), %eax + LONG $0x0d443a41; BYTE $0x00 // cmpb (%r13,%rcx), %al + WORD $0x940f; BYTE $0xc0 // sete %al + LONG $0x001d850f; WORD $0x0000 // jne LBB33_32, $29(%rip) + LONG $0x01518d48 // leaq $1(%rcx), %rdx + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0xffdd850f; WORD $0xffff // jne LBB33_29, $-35(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_32: + WORD $0xb60f; BYTE $0xd8 // movzbl %al, %ebx + +LBB33_33: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + +LBB33_34: + LONG $0xb8658b4c // movq $-72(%rbp), %r12 + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0xffcf17e8; BYTE $0xff // callq _advance_ns, $-12521(%rip) + WORD $0x3a3c // cmpb $58, %al + LONG $0x01b0850f; WORD $0x0000 // jne LBB33_68, $432(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0186850f; WORD $0x0000 // jne LBB33_66, $390(%rip) + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0xfff20be8; BYTE $0xff // callq _skip_one_fast, $-3573(%rip) + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0xffcef0e8; BYTE $0xff // callq _advance_ns, $-12560(%rip) + WORD $0x2c3c // cmpb $44, %al + LONG $0xfda8840f; WORD $0xffff // je LBB33_4, $-600(%rip) + LONG $0x000184e9; BYTE $0x00 // jmp LBB33_68, $388(%rip) + +LBB33_37: + QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx + WORD $0x0149; BYTE $0xcc // addq %rcx, %r12 + LONG $0xc065894c // movq %r12, $-64(%rbp) + LONG $0x01348d48 // leaq (%rcx,%rax), %rsi + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x2f1c8d4b // leaq (%r15,%r13), %rbx + WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 + LONG $0x00c1830f; WORD $0x0000 // jae LBB33_57, $193(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x00b88e0f; WORD $0x0000 // jle LBB33_57, $184(%rip) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0xa8758948 // movq %rsi, $-88(%rbp) + +LBB33_40: + LONG $0x04b60f41; BYTE $0x24 // movzbl (%r12), %eax + WORD $0x5c3c // cmpb $92, %al + LONG $0x005e850f; WORD $0x0000 // jne LBB33_48, $94(%rip) + LONG $0xc07d8d48 // leaq $-64(%rbp), %rdi + LONG $0xc8558d48 // leaq $-56(%rbp), %rdx + LONG $0x0026eee8; BYTE $0x00 // callq _unescape, $9966(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0156880f; WORD $0x0000 // js LBB33_71, $342(%rip) + LONG $0x280c8d48 // leaq (%rax,%rbp), %rcx + LONG $0xc8c18348 // addq $-56, %rcx + WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 + LONG $0x0050830f; WORD $0x0000 // jae LBB33_51, $80(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0047840f; WORD $0x0000 // je LBB33_51, $71(%rip) + LONG $0xc8458d48 // leaq $-56(%rbp), %rax + +LBB33_45: + LONG $0x55b60f41; BYTE $0x00 // movzbl (%r13), %edx + WORD $0x103a // cmpb (%rax), %dl + LONG $0x003a850f; WORD $0x0000 // jne LBB33_52, $58(%rip) + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 + LONG $0x002b830f; WORD $0x0000 // jae LBB33_52, $43(%rip) + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0xffdb820f; WORD $0xffff // jb LBB33_45, $-37(%rip) + LONG $0x00001de9; BYTE $0x00 // jmp LBB33_52, $29(%rip) + +LBB33_48: + LONG $0x00453a41 // cmpb (%r13), %al + LONG $0x0052850f; WORD $0x0000 // jne LBB33_60, $82(%rip) + WORD $0xff49; BYTE $0xc4 // incq %r12 + LONG $0xc065894c // movq %r12, $-64(%rbp) + WORD $0xff49; BYTE $0xc5 // incq %r13 + LONG $0x000015e9; BYTE $0x00 // jmp LBB33_54, $21(%rip) + +LBB33_51: + LONG $0xc8458d48 // leaq $-56(%rbp), %rax + +LBB33_52: + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x0036850f; WORD $0x0000 // jne LBB33_60, $54(%rip) + LONG $0xc0658b4c // movq $-64(%rbp), %r12 + LONG $0xa8758b48 // movq $-88(%rbp), %rsi + +LBB33_54: + WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 + LONG $0x0012830f; WORD $0x0000 // jae LBB33_58, $18(%rip) + WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 + LONG $0xff55820f; WORD $0xffff // jb LBB33_40, $-171(%rip) + LONG $0x000004e9; BYTE $0x00 // jmp LBB33_58, $4(%rip) + +LBB33_57: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + +LBB33_58: + WORD $0x3149; BYTE $0xf4 // xorq %rsi, %r12 + WORD $0x3149; BYTE $0xdd // xorq %rbx, %r13 + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x094d; BYTE $0xe5 // orq %r12, %r13 + WORD $0x940f; BYTE $0xc3 // sete %bl + LONG $0xfffeb8e9; BYTE $0xff // jmp LBB33_34, $-328(%rip) + +LBB33_60: + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xfffeb1e9; BYTE $0xff // jmp LBB33_34, $-335(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB33_61: + WORD $0xf980; BYTE $0x02 // cmpb $2, %cl + LONG $0x0068850f; WORD $0x0000 // jne LBB33_68, $104(%rip) + WORD $0x5b3c // cmpb $91, %al + LONG $0x0060850f; WORD $0x0000 // jne LBB33_68, $96(%rip) + LONG $0x24448b49; BYTE $0x08 // movq $8(%r12), %rax + WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x90909090 // .p2align 4, 0x90 + +LBB33_64: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00248e0f; WORD $0x0000 // jle LBB33_66, $36(%rip) + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0xfff0a9e8; BYTE $0xff // callq _skip_one_fast, $-3927(%rip) + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0xffcd8ee8; BYTE $0xff // callq _advance_ns, $-12914(%rip) + WORD $0x2c3c // cmpb $44, %al + LONG $0xffd6840f; WORD $0xffff // je LBB33_64, $-42(%rip) + LONG $0x000022e9; BYTE $0x00 // jmp LBB33_68, $34(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB33_66: + LONG $0x10c48349 // addq $16, %r12 + LONG $0xa0458b48 // movq $-96(%rbp), %rax + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0xfbf1850f; WORD $0xffff // jne LBB33_2, $-1039(%rip) + +LBB33_67: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0xfff074e8; BYTE $0xff // callq _skip_one_fast, $-3980(%rip) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB33_69, $10(%rip) + +LBB33_68: + WORD $0xff49; BYTE $0x0e // decq (%r14) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + +LBB33_69: + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB33_70: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + LONG $0x08408b48 // movq $8(%rax), %rax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffffdae9; BYTE $0xff // jmp LBB33_69, $-38(%rip) + +LBB33_71: + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x2b49; BYTE $0x0f // subq (%r15), %rcx + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0xffffcbe9; BYTE $0xff // jmp LBB33_69, $-53(%rip) + + // .p2align 4, 0x90 +_validate_utf8: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x1a048d4f // leaq (%r10,%r11), %r8 + LONG $0xfdc08349 // addq $-3, %r8 + LONG $0x00000de9; BYTE $0x00 // jmp LBB34_1, $13(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB34_19: + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + +LBB34_1: + WORD $0x394c; BYTE $0xc1 // cmpq %r8, %rcx + LONG $0x00e1830f; WORD $0x0000 // jae LBB34_2, $225(%rip) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) + LONG $0xffe6890f; WORD $0xffff // jns LBB34_19, $-26(%rip) + WORD $0x018b // movl (%rcx), %eax + WORD $0xc789 // movl %eax, %edi + LONG $0xc0f0e781; WORD $0x00c0 // andl $12632304, %edi + LONG $0x80e0ff81; WORD $0x0080 // cmpl $8421600, %edi + LONG $0x0030850f; WORD $0x0000 // jne LBB34_10, $48(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi + LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi + LONG $0x001c840f; WORD $0x0000 // je LBB34_10, $28(%rip) + LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx + WORD $0xff85 // testl %edi, %edi + LONG $0xffaf850f; WORD $0xffff // jne LBB34_19, $-81(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB34_10: + WORD $0xc789 // movl %eax, %edi + LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi + LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi + LONG $0x0010850f; WORD $0x0000 // jne LBB34_12, $16(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx + WORD $0xe783; BYTE $0x1e // andl $30, %edi + LONG $0xff7c850f; WORD $0xffff // jne LBB34_19, $-132(%rip) + +LBB34_12: + WORD $0xc789 // movl %eax, %edi + LONG $0xc0f8e781; WORD $0xc0c0 // andl $-1061109512, %edi + LONG $0x80f0ff81; WORD $0x8080 // cmpl $-2139062032, %edi + LONG $0x0026850f; WORD $0x0000 // jne LBB34_16, $38(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0x3007e781; WORD $0x0000 // andl $12295, %edi + LONG $0x0018840f; WORD $0x0000 // je LBB34_16, $24(%rip) + LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx + WORD $0x04a8 // testb $4, %al + LONG $0xff4d840f; WORD $0xffff // je LBB34_19, $-179(%rip) + LONG $0x00300325; BYTE $0x00 // andl $12291, %eax + LONG $0xff42840f; WORD $0xffff // je LBB34_19, $-190(%rip) + +LBB34_16: + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x294c; BYTE $0xd7 // subq %r10, %rdi + WORD $0x8b48; BYTE $0x1a // movq (%rdx), %rbx + LONG $0x00fb8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rbx + LONG $0x0187830f; WORD $0x0000 // jae LBB34_17, $391(%rip) + WORD $0x6348; BYTE $0xc7 // movslq %edi, %rax + LONG $0x017b8d48 // leaq $1(%rbx), %rdi + WORD $0x8948; BYTE $0x3a // movq %rdi, (%rdx) + LONG $0xda448948; BYTE $0x08 // movq %rax, $8(%rdx,%rbx,8) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0xffff13e9; BYTE $0xff // jmp LBB34_19, $-237(%rip) + +LBB34_2: + WORD $0x014d; BYTE $0xd3 // addq %r10, %r11 + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x013e830f; WORD $0x0000 // jae LBB34_36, $318(%rip) + LONG $0xdc458d4c // leaq $-36(%rbp), %r8 + LONG $0xda4d8d4c // leaq $-38(%rbp), %r9 + LONG $0x000016e9; BYTE $0x00 // jmp LBB34_4, $22(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB34_5: + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x011b830f; WORD $0x0000 // jae LBB34_36, $283(%rip) + +LBB34_4: + WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) + LONG $0xffeb890f; WORD $0xffff // jns LBB34_5, $-21(%rip) + LONG $0x00dc45c6 // movb $0, $-36(%rbp) + LONG $0x00da45c6 // movb $0, $-38(%rbp) + WORD $0x894c; BYTE $0xdb // movq %r11, %rbx + WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0035820f; WORD $0x0000 // jb LBB34_21, $53(%rip) + LONG $0x21b60f44 // movzbl (%rcx), %r12d + LONG $0x71b60f44; BYTE $0x01 // movzbl $1(%rcx), %r14d + LONG $0xdc658844 // movb %r12b, $-36(%rbp) + LONG $0x02798d4c // leaq $2(%rcx), %r15 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x894c; BYTE $0xcf // movq %r9, %rdi + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0029840f; WORD $0x0000 // je LBB34_24, $41(%rip) + +LBB34_25: + LONG $0x07b60f41 // movzbl (%r15), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x65b60f44; BYTE $0xdc // movzbl $-36(%rbp), %r12d + LONG $0xda7db60f // movzbl $-38(%rbp), %edi + LONG $0x000017e9; BYTE $0x00 // jmp LBB34_26, $23(%rip) + +LBB34_21: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xffd7850f; WORD $0xffff // jne LBB34_25, $-41(%rip) + +LBB34_24: + WORD $0xff31 // xorl %edi, %edi + +LBB34_26: + LONG $0xc7b60f40 // movzbl %dil, %eax + WORD $0xe0c1; BYTE $0x10 // shll $16, %eax + LONG $0xdeb60f41 // movzbl %r14b, %ebx + WORD $0xe3c1; BYTE $0x08 // shll $8, %ebx + WORD $0xc309 // orl %eax, %ebx + LONG $0xfcb60f41 // movzbl %r12b, %edi + WORD $0xdf09 // orl %ebx, %edi + WORD $0xf889 // movl %edi, %eax + LONG $0xc0c0f025; BYTE $0x00 // andl $12632304, %eax + LONG $0x8080e03d; BYTE $0x00 // cmpl $8421600, %eax + LONG $0x001f850f; WORD $0x0000 // jne LBB34_29, $31(%rip) + WORD $0xf889 // movl %edi, %eax + LONG $0x00200f25; BYTE $0x00 // andl $8207, %eax + LONG $0x00200d3d; BYTE $0x00 // cmpl $8205, %eax + LONG $0x000d840f; WORD $0x0000 // je LBB34_29, $13(%rip) + LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx + WORD $0xc085 // testl %eax, %eax + LONG $0x0021850f; WORD $0x0000 // jne LBB34_34, $33(%rip) + + // .p2align 4, 0x90 +LBB34_29: + LONG $0x1ec4f641 // testb $30, %r12b + LONG $0x0028840f; WORD $0x0000 // je LBB34_31, $40(%rip) + LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi + LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx + LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi + LONG $0x0011850f; WORD $0x0000 // jne LBB34_31, $17(%rip) + +LBB34_34: + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0xff1f820f; WORD $0xffff // jb LBB34_4, $-225(%rip) + LONG $0x000035e9; BYTE $0x00 // jmp LBB34_36, $53(%rip) + +LBB34_31: + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + WORD $0x294c; BYTE $0xd0 // subq %r10, %rax + WORD $0x8b48; BYTE $0x3a // movq (%rdx), %rdi + LONG $0x00ff8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rdi + LONG $0x0034830f; WORD $0x0000 // jae LBB34_32, $52(%rip) + WORD $0x9848 // cltq + LONG $0x015f8d48 // leaq $1(%rdi), %rbx + WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) + LONG $0xfa448948; BYTE $0x08 // movq %rax, $8(%rdx,%rdi,8) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0xfee5820f; WORD $0xffff // jb LBB34_4, $-283(%rip) + +LBB34_36: + WORD $0x294c; BYTE $0xd1 // subq %r10, %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + WORD $0xc031 // xorl %eax, %eax + +LBB34_37: + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB34_32: + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffffe4e9; BYTE $0xff // jmp LBB34_37, $-28(%rip) + +LBB34_17: + WORD $0x8948; BYTE $0x3e // movq %rdi, (%rsi) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffffd5e9; BYTE $0xff // jmp LBB34_37, $-43(%rip) + LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 + +LCPI35_0: + QUAD $0x0f0f0f0f0f0f0f0f; QUAD $0x0f0f0f0f0f0f0f0f // .space 16, '\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f' + QUAD $0x0f0f0f0f0f0f0f0f; QUAD $0x0f0f0f0f0f0f0f0f // .space 16, '\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f' + +LCPI35_1: + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x21 // .byte 33 + BYTE $0x01 // .byte 1 + BYTE $0x15 // .byte 21 + BYTE $0x49 // .byte 73 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x02 // .byte 2 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x21 // .byte 33 + BYTE $0x01 // .byte 1 + BYTE $0x15 // .byte 21 + BYTE $0x49 // .byte 73 + +LCPI35_2: + BYTE $0xe7 // .byte 231 + BYTE $0xa3 // .byte 163 + BYTE $0x83 // .byte 131 + BYTE $0x83 // .byte 131 + BYTE $0x8b // .byte 139 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xdb // .byte 219 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xe7 // .byte 231 + BYTE $0xa3 // .byte 163 + BYTE $0x83 // .byte 131 + BYTE $0x83 // .byte 131 + BYTE $0x8b // .byte 139 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + BYTE $0xdb // .byte 219 + BYTE $0xcb // .byte 203 + BYTE $0xcb // .byte 203 + +LCPI35_3: + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0xe6 // .byte 230 + BYTE $0xae // .byte 174 + BYTE $0xba // .byte 186 + BYTE $0xba // .byte 186 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0xe6 // .byte 230 + BYTE $0xae // .byte 174 + BYTE $0xba // .byte 186 + BYTE $0xba // .byte 186 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + BYTE $0x01 // .byte 1 + +LCPI35_4: + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + +LCPI35_5: + QUAD $0xefefefefefefefef; QUAD $0xefefefefefefefef // .space 16, '\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef' + QUAD $0xefefefefefefefef; QUAD $0xefefefefefefefef // .space 16, '\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef' + +LCPI35_7: + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xff // .byte 255 + BYTE $0xef // .byte 239 + BYTE $0xdf // .byte 223 + BYTE $0xbf // .byte 191 + +LCPI35_8: + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 3, 0x00 +LCPI35_6: + QUAD $0x8080808080808080 // .quad -9187201950435737472 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +_validate_utf8_fast: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + LONG $0xe0e48348 // andq $-32, %rsp + LONG $0xa0ec8148; WORD $0x0000; BYTE $0x00 // subq $160, %rsp + LONG $0x08578b4c // movq $8(%rdi), %r10 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0910840f; WORD $0x0000 // je LBB35_22, $2320(%rip) + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + WORD $0x014d; BYTE $0xca // addq %r9, %r10 + LONG $0x80728d49 // leaq $-128(%r10), %rsi + LONG $0xc9eff1c5 // vpxor %xmm1, %xmm1, %xmm1 + LONG $0xd2efe9c5 // vpxor %xmm2, %xmm2, %xmm2 + LONG $0xc0eff9c5 // vpxor %xmm0, %xmm0, %xmm0 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0x394c; BYTE $0xce // cmpq %r9, %rsi + LONG $0x0366860f; WORD $0x0000 // jbe LBB35_12, $870(%rip) + QUAD $0xfffffea9256ffdc5 // vmovdqa $-343(%rip), %ymm4 /* LCPI35_0(%rip) */ + QUAD $0xfffffee1356ffdc5 // vmovdqa $-287(%rip), %ymm6 /* LCPI35_2(%rip) */ + QUAD $0xfffffef93d6ffdc5 // vmovdqa $-263(%rip), %ymm7 /* LCPI35_3(%rip) */ + QUAD $0xffffff11056f7dc5 // vmovdqa $-239(%rip), %ymm8 /* LCPI35_4(%rip) */ + QUAD $0xffffff290d6f7dc5 // vmovdqa $-215(%rip), %ymm9 /* LCPI35_5(%rip) */ + QUAD $0xffffff41156f7dc5 // vmovdqa $-191(%rip), %ymm10 /* LCPI35_7(%rip) */ + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0xc0eff9c5 // vpxor %xmm0, %xmm0, %xmm0 + LONG $0xd2efe9c5 // vpxor %xmm2, %xmm2, %xmm2 + LONG $0xc9eff1c5 // vpxor %xmm1, %xmm1, %xmm1 + WORD $0x9090 // .p2align 4, 0x90 + +LBB35_3: + LONG $0x386f7ec5 // vmovdqu (%rax), %ymm15 + LONG $0x686f7ec5; BYTE $0x20 // vmovdqu $32(%rax), %ymm13 + LONG $0x606f7ec5; BYTE $0x40 // vmovdqu $64(%rax), %ymm12 + LONG $0x586f7ec5; BYTE $0x60 // vmovdqu $96(%rax), %ymm11 + LONG $0xeb15c1c4; BYTE $0xdf // vpor %ymm15, %ymm13, %ymm3 + LONG $0xeb2541c4; BYTE $0xf4 // vpor %ymm12, %ymm11, %ymm14 + LONG $0xebeb8dc5 // vpor %ymm3, %ymm14, %ymm5 + LONG $0xcdd7fdc5 // vpmovmskb %ymm5, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0016850f; WORD $0x0000 // jne LBB35_6, $22(%rip) + LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 + +LBB35_5: + LONG $0x80e88348 // subq $-128, %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffc2820f; WORD $0xffff // jb LBB35_3, $-62(%rip) + LONG $0x0002e2e9; BYTE $0x00 // jmp LBB35_12, $738(%rip) + +LBB35_6: + LONG $0xcbd7fdc5 // vpmovmskb %ymm3, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x00f0850f; WORD $0x0000 // jne LBB35_9, $240(%rip) + LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 + LONG $0x466dc3c4; WORD $0x21cc // vperm2i128 $33, %ymm12, %ymm2, %ymm1 + LONG $0x0f1de3c4; WORD $0x0fd1 // vpalignr $15, %ymm1, %ymm12, %ymm2 + LONG $0xd271e5c5; BYTE $0x04 // vpsrlw $4, %ymm2, %ymm3 + LONG $0xdcdbe5c5 // vpand %ymm4, %ymm3, %ymm3 + QUAD $0xfffffe20356f7dc5 // vmovdqa $-480(%rip), %ymm14 /* LCPI35_1(%rip) */ + LONG $0x000de2c4; BYTE $0xdb // vpshufb %ymm3, %ymm14, %ymm3 + LONG $0xd4dbedc5 // vpand %ymm4, %ymm2, %ymm2 + LONG $0x004de2c4; BYTE $0xd2 // vpshufb %ymm2, %ymm6, %ymm2 + LONG $0x7155c1c4; WORD $0x04d4 // vpsrlw $4, %ymm12, %ymm5 + LONG $0xecdbd5c5 // vpand %ymm4, %ymm5, %ymm5 + LONG $0x0045e2c4; BYTE $0xed // vpshufb %ymm5, %ymm7, %ymm5 + LONG $0xd5dbedc5 // vpand %ymm5, %ymm2, %ymm2 + LONG $0xd2dbe5c5 // vpand %ymm2, %ymm3, %ymm2 + LONG $0x0f1de3c4; WORD $0x0ed9 // vpalignr $14, %ymm1, %ymm12, %ymm3 + LONG $0x0f1de3c4; WORD $0x0dc9 // vpalignr $13, %ymm1, %ymm12, %ymm1 + LONG $0xd865c1c4; BYTE $0xd8 // vpsubusb %ymm8, %ymm3, %ymm3 + LONG $0xd875c1c4; BYTE $0xc9 // vpsubusb %ymm9, %ymm1, %ymm1 + LONG $0xcbebf5c5 // vpor %ymm3, %ymm1, %ymm1 + LONG $0xef1141c4; BYTE $0xed // vpxor %xmm13, %xmm13, %xmm13 + LONG $0xc97495c5 // vpcmpeqb %ymm1, %ymm13, %ymm1 + QUAD $0xfffeaf1d597de2c4; BYTE $0xff // vpbroadcastq $-337(%rip), %ymm3 /* LCPI35_6(%rip) */ + LONG $0xcbdff5c5 // vpandn %ymm3, %ymm1, %ymm1 + LONG $0xcaeff5c5 // vpxor %ymm2, %ymm1, %ymm1 + LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 + LONG $0x461dc3c4; WORD $0x21cb // vperm2i128 $33, %ymm11, %ymm12, %ymm1 + LONG $0x0f25e3c4; WORD $0x0fd1 // vpalignr $15, %ymm1, %ymm11, %ymm2 + LONG $0xd271d5c5; BYTE $0x04 // vpsrlw $4, %ymm2, %ymm5 + LONG $0xecdbd5c5 // vpand %ymm4, %ymm5, %ymm5 + LONG $0x000de2c4; BYTE $0xed // vpshufb %ymm5, %ymm14, %ymm5 + LONG $0xd4dbedc5 // vpand %ymm4, %ymm2, %ymm2 + LONG $0x004de2c4; BYTE $0xd2 // vpshufb %ymm2, %ymm6, %ymm2 + LONG $0x711dc1c4; WORD $0x04d3 // vpsrlw $4, %ymm11, %ymm12 + LONG $0xe4db1dc5 // vpand %ymm4, %ymm12, %ymm12 + LONG $0x004542c4; BYTE $0xe4 // vpshufb %ymm12, %ymm7, %ymm12 + LONG $0xd2db9dc5 // vpand %ymm2, %ymm12, %ymm2 + LONG $0xd2dbd5c5 // vpand %ymm2, %ymm5, %ymm2 + LONG $0x0f25e3c4; WORD $0x0ee9 // vpalignr $14, %ymm1, %ymm11, %ymm5 + LONG $0x0f25e3c4; WORD $0x0dc9 // vpalignr $13, %ymm1, %ymm11, %ymm1 + LONG $0xd855c1c4; BYTE $0xe8 // vpsubusb %ymm8, %ymm5, %ymm5 + LONG $0xd875c1c4; BYTE $0xc9 // vpsubusb %ymm9, %ymm1, %ymm1 + LONG $0xcdebf5c5 // vpor %ymm5, %ymm1, %ymm1 + LONG $0xc97495c5 // vpcmpeqb %ymm1, %ymm13, %ymm1 + LONG $0xcbdff5c5 // vpandn %ymm3, %ymm1, %ymm1 + LONG $0xcaeff5c5 // vpxor %ymm2, %ymm1, %ymm1 + +LBB35_8: + LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 + LONG $0xd825c1c4; BYTE $0xca // vpsubusb %ymm10, %ymm11, %ymm1 + LONG $0xda7f7dc5 // vmovdqa %ymm11, %ymm2 + LONG $0xfffef2e9; BYTE $0xff // jmp LBB35_5, $-270(%rip) + +LBB35_9: + LONG $0x466dc3c4; WORD $0x21cf // vperm2i128 $33, %ymm15, %ymm2, %ymm1 + LONG $0x0f05e3c4; WORD $0x0fd1 // vpalignr $15, %ymm1, %ymm15, %ymm2 + LONG $0xd271e5c5; BYTE $0x04 // vpsrlw $4, %ymm2, %ymm3 + LONG $0xdcdbe5c5 // vpand %ymm4, %ymm3, %ymm3 + QUAD $0xfffffd342d6ffdc5 // vmovdqa $-716(%rip), %ymm5 /* LCPI35_1(%rip) */ + LONG $0x0055e2c4; BYTE $0xdb // vpshufb %ymm3, %ymm5, %ymm3 + LONG $0xd4dbedc5 // vpand %ymm4, %ymm2, %ymm2 + LONG $0x004de2c4; BYTE $0xd2 // vpshufb %ymm2, %ymm6, %ymm2 + LONG $0x7155c1c4; WORD $0x04d7 // vpsrlw $4, %ymm15, %ymm5 + LONG $0xecdbd5c5 // vpand %ymm4, %ymm5, %ymm5 + LONG $0x0045e2c4; BYTE $0xed // vpshufb %ymm5, %ymm7, %ymm5 + LONG $0xd5dbedc5 // vpand %ymm5, %ymm2, %ymm2 + LONG $0xd2dbe5c5 // vpand %ymm2, %ymm3, %ymm2 + LONG $0x0f05e3c4; WORD $0x0ed9 // vpalignr $14, %ymm1, %ymm15, %ymm3 + LONG $0x0f05e3c4; WORD $0x0dc9 // vpalignr $13, %ymm1, %ymm15, %ymm1 + LONG $0xd865c1c4; BYTE $0xd8 // vpsubusb %ymm8, %ymm3, %ymm3 + LONG $0xd875c1c4; BYTE $0xc9 // vpsubusb %ymm9, %ymm1, %ymm1 + LONG $0xcbebf5c5 // vpor %ymm3, %ymm1, %ymm1 + LONG $0xdbefe1c5 // vpxor %xmm3, %xmm3, %xmm3 + LONG $0xdb74f5c5 // vpcmpeqb %ymm3, %ymm1, %ymm3 + QUAD $0xfffdc40d597de2c4; BYTE $0xff // vpbroadcastq $-572(%rip), %ymm1 /* LCPI35_6(%rip) */ + LONG $0xd9dfe5c5 // vpandn %ymm1, %ymm3, %ymm3 + LONG $0xd2efe5c5 // vpxor %ymm2, %ymm3, %ymm2 + LONG $0x547ffdc5; WORD $0x6024 // vmovdqa %ymm2, $96(%rsp) + LONG $0x4605c3c4; WORD $0x21dd // vperm2i128 $33, %ymm13, %ymm15, %ymm3 + LONG $0x0f15e3c4; WORD $0x0feb // vpalignr $15, %ymm3, %ymm13, %ymm5 + LONG $0xd57185c5; BYTE $0x04 // vpsrlw $4, %ymm5, %ymm15 + LONG $0xfcdb05c5 // vpand %ymm4, %ymm15, %ymm15 + QUAD $0xfffffcb9156ffdc5 // vmovdqa $-839(%rip), %ymm2 /* LCPI35_1(%rip) */ + LONG $0x006d42c4; BYTE $0xff // vpshufb %ymm15, %ymm2, %ymm15 + LONG $0xecdbd5c5 // vpand %ymm4, %ymm5, %ymm5 + LONG $0x004de2c4; BYTE $0xed // vpshufb %ymm5, %ymm6, %ymm5 + LONG $0x716dc1c4; WORD $0x04d5 // vpsrlw $4, %ymm13, %ymm2 + LONG $0xd4dbedc5 // vpand %ymm4, %ymm2, %ymm2 + LONG $0x0045e2c4; BYTE $0xd2 // vpshufb %ymm2, %ymm7, %ymm2 + LONG $0xd2dbd5c5 // vpand %ymm2, %ymm5, %ymm2 + LONG $0xd2db85c5 // vpand %ymm2, %ymm15, %ymm2 + LONG $0x0f15e3c4; WORD $0x0eeb // vpalignr $14, %ymm3, %ymm13, %ymm5 + LONG $0x0f15e3c4; WORD $0x0ddb // vpalignr $13, %ymm3, %ymm13, %ymm3 + LONG $0xd855c1c4; BYTE $0xe8 // vpsubusb %ymm8, %ymm5, %ymm5 + LONG $0xd865c1c4; BYTE $0xd9 // vpsubusb %ymm9, %ymm3, %ymm3 + LONG $0xddebe5c5 // vpor %ymm5, %ymm3, %ymm3 + QUAD $0xfffffd321d74e5c5 // vpcmpeqb $-718(%rip), %ymm3, %ymm3 /* LCPI35_8(%rip) */ + LONG $0xd9dfe5c5 // vpandn %ymm1, %ymm3, %ymm3 + LONG $0xd2efe5c5 // vpxor %ymm2, %ymm3, %ymm2 + LONG $0x44ebfdc5; WORD $0x6024 // vpor $96(%rsp), %ymm0, %ymm0 + LONG $0xc2ebfdc5 // vpor %ymm2, %ymm0, %ymm0 + LONG $0xd77dc1c4; BYTE $0xce // vpmovmskb %ymm14, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x00d6840f; WORD $0x0000 // je LBB35_11, $214(%rip) + LONG $0x4615c3c4; WORD $0x21d4 // vperm2i128 $33, %ymm12, %ymm13, %ymm2 + LONG $0x0f1de3c4; WORD $0x0fda // vpalignr $15, %ymm2, %ymm12, %ymm3 + LONG $0xd371d5c5; BYTE $0x04 // vpsrlw $4, %ymm3, %ymm5 + LONG $0xecdbd5c5 // vpand %ymm4, %ymm5, %ymm5 + QUAD $0xfffffc363d6f7dc5 // vmovdqa $-970(%rip), %ymm15 /* LCPI35_1(%rip) */ + LONG $0x0005e2c4; BYTE $0xed // vpshufb %ymm5, %ymm15, %ymm5 + LONG $0xdcdbe5c5 // vpand %ymm4, %ymm3, %ymm3 + LONG $0x004de2c4; BYTE $0xdb // vpshufb %ymm3, %ymm6, %ymm3 + LONG $0x7115c1c4; WORD $0x04d4 // vpsrlw $4, %ymm12, %ymm13 + LONG $0xecdb15c5 // vpand %ymm4, %ymm13, %ymm13 + LONG $0x004542c4; BYTE $0xed // vpshufb %ymm13, %ymm7, %ymm13 + LONG $0xdbdb95c5 // vpand %ymm3, %ymm13, %ymm3 + LONG $0xdbdbd5c5 // vpand %ymm3, %ymm5, %ymm3 + LONG $0x0f1de3c4; WORD $0x0eea // vpalignr $14, %ymm2, %ymm12, %ymm5 + LONG $0x0f1de3c4; WORD $0x0dd2 // vpalignr $13, %ymm2, %ymm12, %ymm2 + LONG $0xd855c1c4; BYTE $0xe8 // vpsubusb %ymm8, %ymm5, %ymm5 + LONG $0xd86dc1c4; BYTE $0xd1 // vpsubusb %ymm9, %ymm2, %ymm2 + LONG $0xd5ebedc5 // vpor %ymm5, %ymm2, %ymm2 + LONG $0xef0941c4; BYTE $0xf6 // vpxor %xmm14, %xmm14, %xmm14 + LONG $0xd2748dc5 // vpcmpeqb %ymm2, %ymm14, %ymm2 + LONG $0xd1dfedc5 // vpandn %ymm1, %ymm2, %ymm2 + LONG $0xd3efedc5 // vpxor %ymm3, %ymm2, %ymm2 + LONG $0x461dc3c4; WORD $0x21db // vperm2i128 $33, %ymm11, %ymm12, %ymm3 + LONG $0x0f25e3c4; WORD $0x0feb // vpalignr $15, %ymm3, %ymm11, %ymm5 + LONG $0xd5719dc5; BYTE $0x04 // vpsrlw $4, %ymm5, %ymm12 + LONG $0xe4db1dc5 // vpand %ymm4, %ymm12, %ymm12 + LONG $0x000542c4; BYTE $0xe4 // vpshufb %ymm12, %ymm15, %ymm12 + LONG $0xecdbd5c5 // vpand %ymm4, %ymm5, %ymm5 + LONG $0x004de2c4; BYTE $0xed // vpshufb %ymm5, %ymm6, %ymm5 + LONG $0x7115c1c4; WORD $0x04d3 // vpsrlw $4, %ymm11, %ymm13 + LONG $0xecdb15c5 // vpand %ymm4, %ymm13, %ymm13 + LONG $0x004542c4; BYTE $0xed // vpshufb %ymm13, %ymm7, %ymm13 + LONG $0xeddb95c5 // vpand %ymm5, %ymm13, %ymm5 + LONG $0xeddb9dc5 // vpand %ymm5, %ymm12, %ymm5 + LONG $0x0f2563c4; WORD $0x0ee3 // vpalignr $14, %ymm3, %ymm11, %ymm12 + LONG $0x0f25e3c4; WORD $0x0ddb // vpalignr $13, %ymm3, %ymm11, %ymm3 + LONG $0xd81d41c4; BYTE $0xe0 // vpsubusb %ymm8, %ymm12, %ymm12 + LONG $0xd865c1c4; BYTE $0xd9 // vpsubusb %ymm9, %ymm3, %ymm3 + LONG $0xdbeb9dc5 // vpor %ymm3, %ymm12, %ymm3 + LONG $0xdb748dc5 // vpcmpeqb %ymm3, %ymm14, %ymm3 + LONG $0xc9dfe5c5 // vpandn %ymm1, %ymm3, %ymm1 + LONG $0xcdeff5c5 // vpxor %ymm5, %ymm1, %ymm1 + LONG $0xc0ebedc5 // vpor %ymm0, %ymm2, %ymm0 + LONG $0xfffe1ae9; BYTE $0xff // jmp LBB35_8, $-486(%rip) + +LBB35_11: + LONG $0xd815c1c4; BYTE $0xca // vpsubusb %ymm10, %ymm13, %ymm1 + LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 + LONG $0xea7f7dc5 // vmovdqa %ymm13, %ymm2 + LONG $0xfffd0ce9; BYTE $0xff // jmp LBB35_5, $-756(%rip) + +LBB35_12: + LONG $0xc0728d49 // leaq $-64(%r10), %rsi + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x0159830f; WORD $0x0000 // jae LBB35_17, $345(%rip) + QUAD $0xfffffb361d6ffdc5 // vmovdqa $-1226(%rip), %ymm3 /* LCPI35_0(%rip) */ + QUAD $0xfffffb4e256ffdc5 // vmovdqa $-1202(%rip), %ymm4 /* LCPI35_1(%rip) */ + QUAD $0xfffffb662d6ffdc5 // vmovdqa $-1178(%rip), %ymm5 /* LCPI35_2(%rip) */ + QUAD $0xfffffb7e356ffdc5 // vmovdqa $-1154(%rip), %ymm6 /* LCPI35_3(%rip) */ + QUAD $0xfffffb963d6ffdc5 // vmovdqa $-1130(%rip), %ymm7 /* LCPI35_4(%rip) */ + QUAD $0xfffffbae056f7dc5 // vmovdqa $-1106(%rip), %ymm8 /* LCPI35_5(%rip) */ + LONG $0xef3141c4; BYTE $0xc9 // vpxor %xmm9, %xmm9, %xmm9 + QUAD $0xfffffbc1156f7dc5 // vmovdqa $-1087(%rip), %ymm10 /* LCPI35_7(%rip) */ + BYTE $0x90 // .p2align 4, 0x90 + +LBB35_14: + LONG $0x206f7ec5 // vmovdqu (%rax), %ymm12 + LONG $0x586f7ec5; BYTE $0x20 // vmovdqu $32(%rax), %ymm11 + LONG $0xeb2541c4; BYTE $0xec // vpor %ymm12, %ymm11, %ymm13 + LONG $0xd77dc1c4; BYTE $0xcd // vpmovmskb %ymm13, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0016850f; WORD $0x0000 // jne LBB35_16, $22(%rip) + LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 + LONG $0x40c08348 // addq $64, %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffd4820f; WORD $0xffff // jb LBB35_14, $-44(%rip) + LONG $0x0000eae9; BYTE $0x00 // jmp LBB35_17, $234(%rip) + +LBB35_16: + LONG $0x466dc3c4; WORD $0x21cc // vperm2i128 $33, %ymm12, %ymm2, %ymm1 + LONG $0x0f1de3c4; WORD $0x0fd1 // vpalignr $15, %ymm1, %ymm12, %ymm2 + LONG $0xd27195c5; BYTE $0x04 // vpsrlw $4, %ymm2, %ymm13 + LONG $0xebdb15c5 // vpand %ymm3, %ymm13, %ymm13 + LONG $0x005d42c4; BYTE $0xed // vpshufb %ymm13, %ymm4, %ymm13 + LONG $0xd3dbedc5 // vpand %ymm3, %ymm2, %ymm2 + LONG $0x0055e2c4; BYTE $0xd2 // vpshufb %ymm2, %ymm5, %ymm2 + LONG $0x710dc1c4; WORD $0x04d4 // vpsrlw $4, %ymm12, %ymm14 + LONG $0xf3db0dc5 // vpand %ymm3, %ymm14, %ymm14 + LONG $0x004d42c4; BYTE $0xf6 // vpshufb %ymm14, %ymm6, %ymm14 + LONG $0xd2db8dc5 // vpand %ymm2, %ymm14, %ymm2 + LONG $0xd2db95c5 // vpand %ymm2, %ymm13, %ymm2 + LONG $0x0f1d63c4; WORD $0x0ee9 // vpalignr $14, %ymm1, %ymm12, %ymm13 + LONG $0x0f1de3c4; WORD $0x0dc9 // vpalignr $13, %ymm1, %ymm12, %ymm1 + LONG $0xefd815c5 // vpsubusb %ymm7, %ymm13, %ymm13 + LONG $0xd875c1c4; BYTE $0xc8 // vpsubusb %ymm8, %ymm1, %ymm1 + LONG $0xc9eb95c5 // vpor %ymm1, %ymm13, %ymm1 + LONG $0xc974b5c5 // vpcmpeqb %ymm1, %ymm9, %ymm1 + QUAD $0xfffb6f2d597d62c4; BYTE $0xff // vpbroadcastq $-1169(%rip), %ymm13 /* LCPI35_6(%rip) */ + LONG $0xdf75c1c4; BYTE $0xcd // vpandn %ymm13, %ymm1, %ymm1 + LONG $0xcaeff5c5 // vpxor %ymm2, %ymm1, %ymm1 + LONG $0x461dc3c4; WORD $0x21d3 // vperm2i128 $33, %ymm11, %ymm12, %ymm2 + LONG $0x0f2563c4; WORD $0x0fe2 // vpalignr $15, %ymm2, %ymm11, %ymm12 + LONG $0x710dc1c4; WORD $0x04d4 // vpsrlw $4, %ymm12, %ymm14 + LONG $0xf3db0dc5 // vpand %ymm3, %ymm14, %ymm14 + LONG $0x005d42c4; BYTE $0xf6 // vpshufb %ymm14, %ymm4, %ymm14 + LONG $0xe3db1dc5 // vpand %ymm3, %ymm12, %ymm12 + LONG $0x005542c4; BYTE $0xe4 // vpshufb %ymm12, %ymm5, %ymm12 + LONG $0x7105c1c4; WORD $0x04d3 // vpsrlw $4, %ymm11, %ymm15 + LONG $0xfbdb05c5 // vpand %ymm3, %ymm15, %ymm15 + LONG $0x004d42c4; BYTE $0xff // vpshufb %ymm15, %ymm6, %ymm15 + LONG $0xdb1d41c4; BYTE $0xe7 // vpand %ymm15, %ymm12, %ymm12 + LONG $0xdb0d41c4; BYTE $0xe4 // vpand %ymm12, %ymm14, %ymm12 + LONG $0x0f2563c4; WORD $0x0ef2 // vpalignr $14, %ymm2, %ymm11, %ymm14 + LONG $0x0f25e3c4; WORD $0x0dd2 // vpalignr $13, %ymm2, %ymm11, %ymm2 + LONG $0xf7d80dc5 // vpsubusb %ymm7, %ymm14, %ymm14 + LONG $0xd86dc1c4; BYTE $0xd0 // vpsubusb %ymm8, %ymm2, %ymm2 + LONG $0xd2eb8dc5 // vpor %ymm2, %ymm14, %ymm2 + LONG $0xd274b5c5 // vpcmpeqb %ymm2, %ymm9, %ymm2 + LONG $0xdf6dc1c4; BYTE $0xd5 // vpandn %ymm13, %ymm2, %ymm2 + LONG $0xd2ef9dc5 // vpxor %ymm2, %ymm12, %ymm2 + LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 + LONG $0xc2ebfdc5 // vpor %ymm2, %ymm0, %ymm0 + LONG $0xd825c1c4; BYTE $0xca // vpsubusb %ymm10, %ymm11, %ymm1 + LONG $0xda7f7dc5 // vmovdqa %ymm11, %ymm2 + LONG $0x40c08348 // addq $64, %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xfee5820f; WORD $0xffff // jb LBB35_14, $-283(%rip) + +LBB35_17: + LONG $0xdbefe1c5 // vpxor %xmm3, %xmm3, %xmm3 + LONG $0x5c7ffdc5; WORD $0x4024 // vmovdqa %ymm3, $64(%rsp) + LONG $0x5c7ffdc5; WORD $0x2024 // vmovdqa %ymm3, $32(%rsp) + LONG $0xe4efd9c5 // vpxor %xmm4, %xmm4, %xmm4 + WORD $0x394c; BYTE $0xd0 // cmpq %r10, %rax + LONG $0x01d7830f; WORD $0x0000 // jae LBB35_39, $471(%rip) + WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi + WORD $0x2948; BYTE $0xc7 // subq %rax, %rdi + WORD $0xf631 // xorl %esi, %esi + LONG $0x10ff8348 // cmpq $16, %rdi + LONG $0x002c820f; WORD $0x0000 // jb LBB35_23, $44(%rip) + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + LONG $0x80fa8148; WORD $0x0000; BYTE $0x00 // cmpq $128, %rdx + LONG $0x0179820f; WORD $0x0000 // jb LBB35_36, $377(%rip) + LONG $0x80ff8148; WORD $0x0000; BYTE $0x00 // cmpq $128, %rdi + LONG $0x000f830f; WORD $0x0000 // jae LBB35_24, $15(%rip) + WORD $0xf631 // xorl %esi, %esi + LONG $0x000114e9; BYTE $0x00 // jmp LBB35_31, $276(%rip) + +LBB35_23: + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + LONG $0x00015de9; BYTE $0x00 // jmp LBB35_36, $349(%rip) + +LBB35_24: + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0x80e68348 // andq $-128, %rsi + LONG $0x804e8d48 // leaq $-128(%rsi), %rcx + WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 + LONG $0x07e8c149 // shrq $7, %r8 + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x012a840f; WORD $0x0000 // je LBB35_34, $298(%rip) + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx + LONG $0xfee28348 // andq $-2, %rdx + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_26: + LONG $0x1c10fcc5; BYTE $0x08 // vmovups (%rax,%rcx), %ymm3 + LONG $0x6410fcc5; WORD $0x2008 // vmovups $32(%rax,%rcx), %ymm4 + LONG $0x6c10fcc5; WORD $0x4008 // vmovups $64(%rax,%rcx), %ymm5 + LONG $0x7410fcc5; WORD $0x6008 // vmovups $96(%rax,%rcx), %ymm6 + LONG $0x5c11fcc5; WORD $0x200c // vmovups %ymm3, $32(%rsp,%rcx) + LONG $0x6411fcc5; WORD $0x400c // vmovups %ymm4, $64(%rsp,%rcx) + LONG $0x6c11fcc5; WORD $0x600c // vmovups %ymm5, $96(%rsp,%rcx) + QUAD $0x0000800cb411fcc5; BYTE $0x00 // vmovups %ymm6, $128(%rsp,%rcx) + QUAD $0x000080089c6ffec5; BYTE $0x00 // vmovdqu $128(%rax,%rcx), %ymm3 + QUAD $0x0000a008a46ffec5; BYTE $0x00 // vmovdqu $160(%rax,%rcx), %ymm4 + QUAD $0x0000c008ac6ffec5; BYTE $0x00 // vmovdqu $192(%rax,%rcx), %ymm5 + QUAD $0x0000e008b46ffec5; BYTE $0x00 // vmovdqu $224(%rax,%rcx), %ymm6 + QUAD $0x0000a00c9c7ffec5; BYTE $0x00 // vmovdqu %ymm3, $160(%rsp,%rcx) + QUAD $0x0000c00ca47ffec5; BYTE $0x00 // vmovdqu %ymm4, $192(%rsp,%rcx) + QUAD $0x0000e00cac7ffec5; BYTE $0x00 // vmovdqu %ymm5, $224(%rsp,%rcx) + QUAD $0x0001000cb47ffec5; BYTE $0x00 // vmovdqu %ymm6, $256(%rsp,%rcx) + LONG $0x00c18148; WORD $0x0001; BYTE $0x00 // addq $256, %rcx + LONG $0xfec28348 // addq $-2, %rdx + LONG $0xff75850f; WORD $0xffff // jne LBB35_26, $-139(%rip) + LONG $0x01c0f641 // testb $1, %r8b + LONG $0x0032840f; WORD $0x0000 // je LBB35_29, $50(%rip) + +LBB35_28: + LONG $0x1c6ffec5; BYTE $0x08 // vmovdqu (%rax,%rcx), %ymm3 + LONG $0x646ffec5; WORD $0x2008 // vmovdqu $32(%rax,%rcx), %ymm4 + LONG $0x6c6ffec5; WORD $0x4008 // vmovdqu $64(%rax,%rcx), %ymm5 + LONG $0x746ffec5; WORD $0x6008 // vmovdqu $96(%rax,%rcx), %ymm6 + LONG $0x5c7ffec5; WORD $0x200c // vmovdqu %ymm3, $32(%rsp,%rcx) + LONG $0x647ffec5; WORD $0x400c // vmovdqu %ymm4, $64(%rsp,%rcx) + LONG $0x6c7ffec5; WORD $0x600c // vmovdqu %ymm5, $96(%rsp,%rcx) + QUAD $0x0000800cb47ffec5; BYTE $0x00 // vmovdqu %ymm6, $128(%rsp,%rcx) + +LBB35_29: + WORD $0x3948; BYTE $0xf7 // cmpq %rsi, %rdi + LONG $0x0083840f; WORD $0x0000 // je LBB35_38, $131(%rip) + LONG $0x70c7f640 // testb $112, %dil + LONG $0x004d840f; WORD $0x0000 // je LBB35_35, $77(%rip) + +LBB35_31: + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0xf0e68348 // andq $-16, %rsi + LONG $0x300c8d48 // leaq (%rax,%rsi), %rcx + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB35_32: + LONG $0x1c6ffac5; BYTE $0x10 // vmovdqu (%rax,%rdx), %xmm3 + LONG $0x5c7ff9c5; WORD $0x2014 // vmovdqa %xmm3, $32(%rsp,%rdx) + LONG $0x10c28348 // addq $16, %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffe8850f; WORD $0xffff // jne LBB35_32, $-24(%rip) + WORD $0x3948; BYTE $0xf7 // cmpq %rsi, %rdi + LONG $0x001a850f; WORD $0x0000 // jne LBB35_36, $26(%rip) + LONG $0x00003de9; BYTE $0x00 // jmp LBB35_38, $61(%rip) + +LBB35_34: + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x01c0f641 // testb $1, %r8b + LONG $0xff73850f; WORD $0xffff // jne LBB35_28, $-141(%rip) + LONG $0xffffa0e9; BYTE $0xff // jmp LBB35_29, $-96(%rip) + +LBB35_35: + LONG $0x300c8d48 // leaq (%rax,%rsi), %rcx + +LBB35_36: + LONG $0x34148d48 // leaq (%rsp,%rsi), %rdx + LONG $0x20c28348 // addq $32, %rdx + WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi + WORD $0x2948; BYTE $0xf7 // subq %rsi, %rdi + WORD $0x2948; BYTE $0xc7 // subq %rax, %rdi + WORD $0xc031 // xorl %eax, %eax + WORD $0x9090 // .p2align 4, 0x90 + +LBB35_37: + LONG $0x011cb60f // movzbl (%rcx,%rax), %ebx + WORD $0x1c88; BYTE $0x02 // movb %bl, (%rdx,%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0xffed850f; WORD $0xffff // jne LBB35_37, $-19(%rip) + +LBB35_38: + LONG $0x646ffdc5; WORD $0x2024 // vmovdqa $32(%rsp), %ymm4 + LONG $0x5c6ffdc5; WORD $0x4024 // vmovdqa $64(%rsp), %ymm3 + +LBB35_39: + LONG $0xebebddc5 // vpor %ymm3, %ymm4, %ymm5 + LONG $0xc5d7fdc5 // vpmovmskb %ymm5, %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x022a850f; WORD $0x0000 // jne LBB35_42, $554(%rip) + LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 + LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 + LONG $0x177de2c4; BYTE $0xc0 // vptest %ymm0, %ymm0 + LONG $0x020b840f; WORD $0x0000 // je LBB35_22, $523(%rip) + +LBB35_43: + LONG $0xfd728d49 // leaq $-3(%r10), %rsi + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0x394c; BYTE $0xce // cmpq %r9, %rsi + LONG $0x00de860f; WORD $0x0000 // jbe LBB35_57, $222(%rip) + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0x000012e9; BYTE $0x00 // jmp LBB35_46, $18(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB35_45: + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x00c4830f; WORD $0x0000 // jae LBB35_57, $196(%rip) + +LBB35_46: + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) + LONG $0xffe6890f; WORD $0xffff // jns LBB35_45, $-26(%rip) + WORD $0x088b // movl (%rax), %ecx + WORD $0xca89 // movl %ecx, %edx + LONG $0xc0f0e281; WORD $0x00c0 // andl $12632304, %edx + LONG $0x80e0fa81; WORD $0x0080 // cmpl $8421600, %edx + LONG $0x0030850f; WORD $0x0000 // jne LBB35_50, $48(%rip) + WORD $0xcf89 // movl %ecx, %edi + LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi + LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi + LONG $0x001c840f; WORD $0x0000 // je LBB35_50, $28(%rip) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + WORD $0xff85 // testl %edi, %edi + LONG $0xffaf850f; WORD $0xffff // jne LBB35_45, $-81(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_50: + WORD $0xca89 // movl %ecx, %edx + LONG $0xc0e0e281; WORD $0x0000 // andl $49376, %edx + LONG $0x80c0fa81; WORD $0x0000 // cmpl $32960, %edx + LONG $0x0010850f; WORD $0x0000 // jne LBB35_52, $16(%rip) + WORD $0xcf89 // movl %ecx, %edi + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + WORD $0xe783; BYTE $0x1e // andl $30, %edi + LONG $0xff7c850f; WORD $0xffff // jne LBB35_45, $-132(%rip) + +LBB35_52: + WORD $0xca89 // movl %ecx, %edx + LONG $0xc0f8e281; WORD $0xc0c0 // andl $-1061109512, %edx + LONG $0x80f0fa81; WORD $0x8080 // cmpl $-2139062032, %edx + LONG $0x0028850f; WORD $0x0000 // jne LBB35_56, $40(%rip) + WORD $0xca89 // movl %ecx, %edx + LONG $0x3007e281; WORD $0x0000 // andl $12295, %edx + LONG $0x001a840f; WORD $0x0000 // je LBB35_56, $26(%rip) + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + WORD $0xc1f6; BYTE $0x04 // testb $4, %cl + LONG $0xff4c840f; WORD $0xffff // je LBB35_45, $-180(%rip) + LONG $0x3003e181; WORD $0x0000 // andl $12291, %ecx + LONG $0xff40840f; WORD $0xffff // je LBB35_45, $-192(%rip) + +LBB35_56: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xc8 // addq %r9, %rax + LONG $0xf8658d48 // leaq $-8(%rbp), %rsp + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB35_57: + WORD $0x394c; BYTE $0xd0 // cmpq %r10, %rax + LONG $0x0114830f; WORD $0x0000 // jae LBB35_22, $276(%rip) + LONG $0x24448d4c; BYTE $0x20 // leaq $32(%rsp), %r8 + LONG $0x245c8d4c; BYTE $0x1e // leaq $30(%rsp), %r11 + LONG $0x000014e9; BYTE $0x00 // jmp LBB35_60, $20(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB35_59: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xd0 // cmpq %r10, %rax + LONG $0x00f1830f; WORD $0x0000 // jae LBB35_22, $241(%rip) + +LBB35_60: + WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) + LONG $0xffeb890f; WORD $0xffff // jns LBB35_59, $-21(%rip) + LONG $0x202444c6; BYTE $0x00 // movb $0, $32(%rsp) + LONG $0x1e2444c6; BYTE $0x00 // movb $0, $30(%rsp) + WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0034820f; WORD $0x0000 // jb LBB35_64, $52(%rip) + WORD $0xb60f; BYTE $0x30 // movzbl (%rax), %esi + LONG $0x0148b60f // movzbl $1(%rax), %ecx + LONG $0x24748840; BYTE $0x20 // movb %sil, $32(%rsp) + LONG $0x02788d48 // leaq $2(%rax), %rdi + LONG $0xfec28348 // addq $-2, %rdx + WORD $0x894c; BYTE $0xdb // movq %r11, %rbx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0027840f; WORD $0x0000 // je LBB35_65, $39(%rip) + +LBB35_63: + WORD $0xb60f; BYTE $0x17 // movzbl (%rdi), %edx + WORD $0x1388 // movb %dl, (%rbx) + LONG $0x2474b60f; BYTE $0x20 // movzbl $32(%rsp), %esi + LONG $0x2454b60f; BYTE $0x1e // movzbl $30(%rsp), %edx + LONG $0x000015e9; BYTE $0x00 // jmp LBB35_66, $21(%rip) + +LBB35_64: + WORD $0xf631 // xorl %esi, %esi + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffd9850f; WORD $0xffff // jne LBB35_63, $-39(%rip) + +LBB35_65: + WORD $0xd231 // xorl %edx, %edx + +LBB35_66: + WORD $0xb60f; BYTE $0xd2 // movzbl %dl, %edx + WORD $0xe2c1; BYTE $0x10 // shll $16, %edx + WORD $0xb60f; BYTE $0xf9 // movzbl %cl, %edi + WORD $0xe7c1; BYTE $0x08 // shll $8, %edi + WORD $0xd709 // orl %edx, %edi + LONG $0xceb60f40 // movzbl %sil, %ecx + WORD $0xf909 // orl %edi, %ecx + WORD $0xca89 // movl %ecx, %edx + LONG $0xc0f0e281; WORD $0x00c0 // andl $12632304, %edx + LONG $0x80e0fa81; WORD $0x0080 // cmpl $8421600, %edx + LONG $0x0030850f; WORD $0x0000 // jne LBB35_69, $48(%rip) + WORD $0xcf89 // movl %ecx, %edi + LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi + LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi + LONG $0x001c840f; WORD $0x0000 // je LBB35_69, $28(%rip) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + WORD $0xff85 // testl %edi, %edi + LONG $0x0030850f; WORD $0x0000 // jne LBB35_71, $48(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_69: + LONG $0x1ec6f640 // testb $30, %sil + LONG $0xfef6840f; WORD $0xffff // je LBB35_56, $-266(%rip) + LONG $0xc0e0e181; WORD $0x0000 // andl $49376, %ecx + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + LONG $0x80c0f981; WORD $0x0000 // cmpl $32960, %ecx + LONG $0xfedf850f; WORD $0xffff // jne LBB35_56, $-289(%rip) + +LBB35_71: + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax + WORD $0x394c; BYTE $0xd0 // cmpq %r10, %rax + LONG $0xff0f820f; WORD $0xffff // jb LBB35_60, $-241(%rip) + +LBB35_22: + WORD $0xc031 // xorl %eax, %eax + LONG $0xf8658d48 // leaq $-8(%rbp), %rsp + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB35_42: + LONG $0x466de3c4; WORD $0x21d4 // vperm2i128 $33, %ymm4, %ymm2, %ymm2 + LONG $0x0f5de3c4; WORD $0x0fea // vpalignr $15, %ymm2, %ymm4, %ymm5 + LONG $0xd571cdc5; BYTE $0x04 // vpsrlw $4, %ymm5, %ymm6 + QUAD $0xfffff59e0d6ffdc5 // vmovdqa $-2658(%rip), %ymm1 /* LCPI35_0(%rip) */ + LONG $0xf1dbcdc5 // vpand %ymm1, %ymm6, %ymm6 + QUAD $0xfffff5b23d6ffdc5 // vmovdqa $-2638(%rip), %ymm7 /* LCPI35_1(%rip) */ + LONG $0x0045e2c4; BYTE $0xf6 // vpshufb %ymm6, %ymm7, %ymm6 + LONG $0xe9dbd5c5 // vpand %ymm1, %ymm5, %ymm5 + QUAD $0xfffff5c1056f7dc5 // vmovdqa $-2623(%rip), %ymm8 /* LCPI35_2(%rip) */ + LONG $0x003de2c4; BYTE $0xed // vpshufb %ymm5, %ymm8, %ymm5 + LONG $0xd471b5c5; BYTE $0x04 // vpsrlw $4, %ymm4, %ymm9 + LONG $0xc9db35c5 // vpand %ymm1, %ymm9, %ymm9 + QUAD $0xfffff5cb156f7dc5 // vmovdqa $-2613(%rip), %ymm10 /* LCPI35_3(%rip) */ + LONG $0x002d42c4; BYTE $0xc9 // vpshufb %ymm9, %ymm10, %ymm9 + LONG $0xeddbb5c5 // vpand %ymm5, %ymm9, %ymm5 + LONG $0xeddbcdc5 // vpand %ymm5, %ymm6, %ymm5 + LONG $0x0f5de3c4; WORD $0x0ef2 // vpalignr $14, %ymm2, %ymm4, %ymm6 + LONG $0x0f5de3c4; WORD $0x0dd2 // vpalignr $13, %ymm2, %ymm4, %ymm2 + QUAD $0xfffff5ca0d6f7dc5 // vmovdqa $-2614(%rip), %ymm9 /* LCPI35_4(%rip) */ + LONG $0xd84dc1c4; BYTE $0xf1 // vpsubusb %ymm9, %ymm6, %ymm6 + QUAD $0xfffff5dd1d6f7dc5 // vmovdqa $-2595(%rip), %ymm11 /* LCPI35_5(%rip) */ + LONG $0xd86dc1c4; BYTE $0xd3 // vpsubusb %ymm11, %ymm2, %ymm2 + LONG $0xd6ebedc5 // vpor %ymm6, %ymm2, %ymm2 + LONG $0xf6efc9c5 // vpxor %xmm6, %xmm6, %xmm6 + LONG $0xd674edc5 // vpcmpeqb %ymm6, %ymm2, %ymm2 + QUAD $0xfff62325597d62c4; BYTE $0xff // vpbroadcastq $-2525(%rip), %ymm12 /* LCPI35_6(%rip) */ + LONG $0xdf6dc1c4; BYTE $0xd4 // vpandn %ymm12, %ymm2, %ymm2 + LONG $0xd5efedc5 // vpxor %ymm5, %ymm2, %ymm2 + LONG $0x465de3c4; WORD $0x21e3 // vperm2i128 $33, %ymm3, %ymm4, %ymm4 + LONG $0x0f65e3c4; WORD $0x0fec // vpalignr $15, %ymm4, %ymm3, %ymm5 + LONG $0xd57195c5; BYTE $0x04 // vpsrlw $4, %ymm5, %ymm13 + LONG $0xe9db15c5 // vpand %ymm1, %ymm13, %ymm13 + LONG $0x0045c2c4; BYTE $0xfd // vpshufb %ymm13, %ymm7, %ymm7 + LONG $0xe9dbd5c5 // vpand %ymm1, %ymm5, %ymm5 + LONG $0x003de2c4; BYTE $0xed // vpshufb %ymm5, %ymm8, %ymm5 + LONG $0xd371bdc5; BYTE $0x04 // vpsrlw $4, %ymm3, %ymm8 + LONG $0xc9dbbdc5 // vpand %ymm1, %ymm8, %ymm1 + LONG $0x002de2c4; BYTE $0xc9 // vpshufb %ymm1, %ymm10, %ymm1 + LONG $0xc9dbd5c5 // vpand %ymm1, %ymm5, %ymm1 + LONG $0xc9dbc5c5 // vpand %ymm1, %ymm7, %ymm1 + LONG $0x0f65e3c4; WORD $0x0eec // vpalignr $14, %ymm4, %ymm3, %ymm5 + LONG $0x0f65e3c4; WORD $0x0de4 // vpalignr $13, %ymm4, %ymm3, %ymm4 + LONG $0xd855c1c4; BYTE $0xe9 // vpsubusb %ymm9, %ymm5, %ymm5 + LONG $0xd85dc1c4; BYTE $0xe3 // vpsubusb %ymm11, %ymm4, %ymm4 + LONG $0xe5ebddc5 // vpor %ymm5, %ymm4, %ymm4 + LONG $0xe674ddc5 // vpcmpeqb %ymm6, %ymm4, %ymm4 + LONG $0xdf5dc1c4; BYTE $0xe4 // vpandn %ymm12, %ymm4, %ymm4 + LONG $0xc9efddc5 // vpxor %ymm1, %ymm4, %ymm1 + LONG $0xc0ebedc5 // vpor %ymm0, %ymm2, %ymm0 + LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 + QUAD $0xfffff56a0dd8e5c5 // vpsubusb $-2710(%rip), %ymm3, %ymm1 /* LCPI35_7(%rip) */ + LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 + LONG $0x177de2c4; BYTE $0xc0 // vptest %ymm0, %ymm0 + LONG $0xfed8840f; WORD $0xffff // je LBB35_22, $-296(%rip) + LONG $0xfffcc8e9; BYTE $0xff // jmp LBB35_43, $-824(%rip) + QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 + +LCPI36_0: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x00 +LCPI36_1: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x90 +_f32toa: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + LONG $0xc07ef9c5 // vmovd %xmm0, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x17 // shrl $23, %ecx + WORD $0xb60f; BYTE $0xd1 // movzbl %cl, %edx + LONG $0x00fffa81; WORD $0x0000 // cmpl $255, %edx + LONG $0x0df0840f; WORD $0x0000 // je LBB36_141, $3568(%rip) + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d + LONG $0x1fe9c141 // shrl $31, %r9d + LONG $0x0f2c8d4e // leaq (%rdi,%r9), %r13 + LONG $0xffffffa9; BYTE $0x7f // testl $2147483647, %eax + LONG $0x01cd840f; WORD $0x0000 // je LBB36_6, $461(%rip) + LONG $0x7fffff25; BYTE $0x00 // andl $8388607, %eax + WORD $0xd285 // testl %edx, %edx + LONG $0x0dd1840f; WORD $0x0000 // je LBB36_142, $3537(%rip) + LONG $0x00b88d44; WORD $0x8000; BYTE $0x00 // leal $8388608(%rax), %r15d + LONG $0x6a828d44; WORD $0xffff; BYTE $0xff // leal $-150(%rdx), %r8d + WORD $0x4a8d; BYTE $0x81 // leal $-127(%rdx), %ecx + WORD $0xf983; BYTE $0x17 // cmpl $23, %ecx + LONG $0x001c870f; WORD $0x0000 // ja LBB36_7, $28(%rip) + LONG $0x000096b9; BYTE $0x00 // movl $150, %ecx + WORD $0xd129 // subl %edx, %ecx + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx + WORD $0xd3f7 // notl %ebx + WORD $0x8544; BYTE $0xfb // testl %r15d, %ebx + LONG $0x043c840f; WORD $0x0000 // je LBB36_33, $1084(%rip) + +LBB36_7: + LONG $0xd07d8948 // movq %rdi, $-48(%rbp) + +LBB36_8: + WORD $0x8945; BYTE $0xfe // movl %r15d, %r14d + LONG $0x01e68341 // andl $1, %r14d + WORD $0xc085 // testl %eax, %eax + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0xfa83; BYTE $0x02 // cmpl $2, %edx + WORD $0x930f; BYTE $0xc1 // setae %cl + WORD $0xc120 // andb %al, %cl + WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx + WORD $0x8945; BYTE $0xfa // movl %r15d, %r10d + LONG $0x02e2c141 // shll $2, %r10d + LONG $0xb9048d42 // leal (%rcx,%r15,4), %eax + WORD $0xc083; BYTE $0xfe // addl $-2, %eax + LONG $0x13d06941; WORD $0x1344; BYTE $0x00 // imull $1262611, %r8d, %edx + LONG $0x019a8d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rdx), %r11d + WORD $0xc984 // testb %cl, %cl + LONG $0xda440f44 // cmovel %edx, %r11d + LONG $0x16fbc141 // sarl $22, %r11d + LONG $0xb1cb6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r11d, %ecx + WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx + WORD $0x0144; BYTE $0xc1 // addl %r8d, %ecx + LONG $0x00001fba; BYTE $0x00 // movl $31, %edx + WORD $0x2944; BYTE $0xda // subl %r11d, %edx + LONG $0x713d8d48; WORD $0x00b8; BYTE $0x00 // leaq $47217(%rip), %rdi /* _pow10_ceil_sig_f32.g(%rip) */ + WORD $0xc1fe // incb %cl + WORD $0xe0d3 // shll %cl, %eax + LONG $0xd7248b4c // movq (%rdi,%rdx,8), %r12 + WORD $0xf749; BYTE $0xe4 // mulq %r12 + QUAD $0x00000002bd048d46 // leal $2(,%r15,4), %r8d + WORD $0xf631 // xorl %esi, %esi + LONG $0x21e8c148 // shrq $33, %rax + LONG $0xc6950f40 // setne %sil + WORD $0xd609 // orl %edx, %esi + WORD $0xd341; BYTE $0xe2 // shll %cl, %r10d + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0xf749; BYTE $0xe4 // mulq %r12 + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + LONG $0x21e8c148 // shrq $33, %rax + LONG $0xc7950f41 // setne %r15b + WORD $0x0945; BYTE $0xd7 // orl %r10d, %r15d + WORD $0xd341; BYTE $0xe0 // shll %cl, %r8d + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0xf749; BYTE $0xe4 // mulq %r12 + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x21e8c148 // shrq $33, %rax + WORD $0x950f; BYTE $0xc1 // setne %cl + WORD $0xd109 // orl %edx, %ecx + WORD $0x0144; BYTE $0xf6 // addl %r14d, %esi + WORD $0x2944; BYTE $0xf1 // subl %r14d, %ecx + LONG $0x28ff8341 // cmpl $40, %r15d + LONG $0x0041820f; WORD $0x0000 // jb LBB36_10, $65(%rip) + WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax + LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx + LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xf089 // movl %esi, %eax + QUAD $0x00000000d53c8d48 // leaq (,%rdx,8), %rdi + LONG $0xbf1c8d48 // leaq (%rdi,%rdi,4), %rbx + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0xc6920f41 // setb %r14b + LONG $0xbf3c8d48 // leaq (%rdi,%rdi,4), %rdi + LONG $0x28c78348 // addq $40, %rdi + WORD $0xcb89 // movl %ecx, %ebx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xdf // cmpq %rbx, %rdi + LONG $0xc0960f41 // setbe %r8b + WORD $0x3845; BYTE $0xc6 // cmpb %r8b, %r14b + LONG $0x01f9840f; WORD $0x0000 // je LBB36_18, $505(%rip) + +LBB36_10: + WORD $0x8945; BYTE $0xd0 // movl %r10d, %r8d + LONG $0x02e8c141 // shrl $2, %r8d + WORD $0x8944; BYTE $0xd2 // movl %r10d, %edx + WORD $0xe283; BYTE $0xfc // andl $-4, %edx + WORD $0xd639 // cmpl %edx, %esi + LONG $0xc6970f40 // seta %sil + WORD $0x428d; BYTE $0x04 // leal $4(%rdx), %eax + WORD $0xc839 // cmpl %ecx, %eax + WORD $0x960f; BYTE $0xc3 // setbe %bl + WORD $0x3040; BYTE $0xf3 // xorb %sil, %bl + LONG $0x007e840f; WORD $0x0000 // je LBB36_14, $126(%rip) + WORD $0xca83; BYTE $0x02 // orl $2, %edx + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x3941; BYTE $0xd7 // cmpl %edx, %r15d + LONG $0x000e870f; WORD $0x0000 // ja LBB36_13, $14(%rip) + WORD $0x940f; BYTE $0xc0 // sete %al + LONG $0x02eac041 // shrb $2, %r10b + WORD $0x2041; BYTE $0xc2 // andb %al, %r10b + LONG $0xc2b60f41 // movzbl %r10b, %eax + +LBB36_13: + WORD $0x0144; BYTE $0xc0 // addl %r8d, %eax + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax + LONG $0xd06d8b4c // movq $-48(%rbp), %r13 + LONG $0x0065820f; WORD $0x0000 // jb LBB36_19, $101(%rip) + +LBB36_15: + LONG $0x0006bc41; WORD $0x0000 // movl $6, %r12d + LONG $0x0f42403d; BYTE $0x00 // cmpl $1000000, %eax + LONG $0x0093820f; WORD $0x0000 // jb LBB36_23, $147(%rip) + LONG $0x0007bc41; WORD $0x0000 // movl $7, %r12d + LONG $0x9896803d; BYTE $0x00 // cmpl $10000000, %eax + LONG $0x0082820f; WORD $0x0000 // jb LBB36_23, $130(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xf5e1003d; BYTE $0x05 // cmpl $100000000, %eax + LONG $0xc4920f41 // setb %r12b + LONG $0x09f48341 // xorl $9, %r12d + LONG $0x00006de9; BYTE $0x00 // jmp LBB36_23, $109(%rip) + +LBB36_6: + LONG $0x0045c641; BYTE $0x30 // movb $48, (%r13) + WORD $0x2941; BYTE $0xfd // subl %edi, %r13d + WORD $0xff41; BYTE $0xc5 // incl %r13d + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + LONG $0x000be5e9; BYTE $0x00 // jmp LBB36_93, $3045(%rip) + +LBB36_14: + WORD $0xc139 // cmpl %eax, %ecx + LONG $0xffd88341 // sbbl $-1, %r8d + WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax + LONG $0xd06d8b4c // movq $-48(%rbp), %r13 + LONG $0xff9b830f; WORD $0xffff // jae LBB36_15, $-101(%rip) + +LBB36_19: + LONG $0x0001bc41; WORD $0x0000 // movl $1, %r12d + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x0030820f; WORD $0x0000 // jb LBB36_23, $48(%rip) + LONG $0x0002bc41; WORD $0x0000 // movl $2, %r12d + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0x0021820f; WORD $0x0000 // jb LBB36_23, $33(%rip) + LONG $0x0003bc41; WORD $0x0000 // movl $3, %r12d + LONG $0x0003e83d; BYTE $0x00 // cmpl $1000, %eax + LONG $0x0010820f; WORD $0x0000 // jb LBB36_23, $16(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0xc4920f41 // setb %r12b + LONG $0x05f48341 // xorl $5, %r12d + +LBB36_23: + LONG $0x1c148d47 // leal (%r12,%r11), %r10d + LONG $0x1c0c8d43 // leal (%r12,%r11), %ecx + WORD $0xc183; BYTE $0xea // addl $-22, %ecx + WORD $0xf983; BYTE $0xe4 // cmpl $-28, %ecx + LONG $0x0077870f; WORD $0x0000 // ja LBB36_27, $119(%rip) + WORD $0x8944; BYTE $0xe1 // movl %r12d, %ecx + LONG $0x0f148d49 // leaq (%r15,%rcx), %rdx + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0x00f3820f; WORD $0x0000 // jb LBB36_31, $243(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0xb71759be; BYTE $0xd1 // movl $3518437209, %esi + LONG $0xf7af0f48 // imulq %rdi, %rsi + LONG $0x2deec148 // shrq $45, %rsi + LONG $0xf0c66944; WORD $0xffd8; BYTE $0xff // imull $-10000, %esi, %r8d + WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d + LONG $0x0464840f; WORD $0x0000 // je LBB36_59, $1124(%rip) + WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi + WORD $0x2941; BYTE $0xf8 // subl %edi, %r8d + LONG $0xf43d8d48; WORD $0x0042; BYTE $0x00 // leaq $17140(%rip), %rdi /* _Digits(%rip) */ + LONG $0x1cb70f42; BYTE $0x47 // movzwl (%rdi,%r8,2), %ebx + LONG $0xfe5a8966 // movw %bx, $-2(%rdx) + LONG $0x4704b70f // movzwl (%rdi,%rax,2), %eax + LONG $0xfc428966 // movw %ax, $-4(%rdx) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x00a6830f; WORD $0x0000 // jae LBB36_61, $166(%rip) + +LBB36_32: + WORD $0xf089 // movl %esi, %eax + LONG $0x0000dbe9; BYTE $0x00 // jmp LBB36_63, $219(%rip) + +LBB36_27: + WORD $0x8945; BYTE $0xe0 // movl %r12d, %r8d + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x023a880f; WORD $0x0000 // js LBB36_36, $570(%rip) + LONG $0x070c8d4b // leaq (%r15,%r8), %rcx + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0x0295820f; WORD $0x0000 // jb LBB36_41, $661(%rip) + WORD $0xc289 // movl %eax, %edx + LONG $0xb71759be; BYTE $0xd1 // movl $3518437209, %esi + LONG $0xf2af0f48 // imulq %rdx, %rsi + LONG $0x2deec148 // shrq $45, %rsi + LONG $0xd8f0d669; WORD $0xffff // imull $-10000, %esi, %edx + WORD $0xc201 // addl %eax, %edx + LONG $0x1fc26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi + WORD $0xfa29 // subl %edi, %edx + LONG $0x833d8d48; WORD $0x0042; BYTE $0x00 // leaq $17027(%rip), %rdi /* _Digits(%rip) */ + LONG $0x5714b70f // movzwl (%rdi,%rdx,2), %edx + LONG $0xfe518966 // movw %dx, $-2(%rcx) + LONG $0xfc518d48 // leaq $-4(%rcx), %rdx + LONG $0x4704b70f // movzwl (%rdi,%rax,2), %eax + LONG $0xfc418966 // movw %ax, $-4(%rcx) + WORD $0xf089 // movl %esi, %eax + WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0x0254830f; WORD $0x0000 // jae LBB36_42, $596(%rip) + +LBB36_30: + WORD $0xc689 // movl %eax, %esi + LONG $0x000288e9; BYTE $0x00 // jmp LBB36_44, $648(%rip) + +LBB36_18: + WORD $0x8844; BYTE $0xc0 // movb %r8b, %al + WORD $0xd001 // addl %edx, %eax + WORD $0xff41; BYTE $0xc3 // incl %r11d + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax + LONG $0xd06d8b4c // movq $-48(%rbp), %r13 + LONG $0xfe45830f; WORD $0xffff // jae LBB36_15, $-443(%rip) + LONG $0xfffea5e9; BYTE $0xff // jmp LBB36_19, $-347(%rip) + +LBB36_31: + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xc689 // movl %eax, %esi + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0xff5a820f; WORD $0xffff // jb LBB36_32, $-166(%rip) + +LBB36_61: + WORD $0xff48; BYTE $0xca // decq %rdx + LONG $0x231d8d4c; WORD $0x0042; BYTE $0x00 // leaq $16931(%rip), %r11 /* _Digits(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_62: + WORD $0xf089 // movl %esi, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi + WORD $0xf389 // movl %esi, %ebx + WORD $0xfb29 // subl %edi, %ebx + LONG $0x3cb70f41; BYTE $0x5b // movzwl (%r11,%rbx,2), %edi + LONG $0xff7a8966 // movw %di, $-1(%rdx) + LONG $0xfec28348 // addq $-2, %rdx + LONG $0x270ffe81; WORD $0x0000 // cmpl $9999, %esi + WORD $0xc689 // movl %eax, %esi + LONG $0xffd1870f; WORD $0xffff // ja LBB36_62, $-47(%rip) + +LBB36_63: + LONG $0x01578d49 // leaq $1(%r15), %rdx + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x001f820f; WORD $0x0000 // jb LBB36_65, $31(%rip) + WORD $0xc689 // movl %eax, %esi + LONG $0xdb3d8d48; WORD $0x0041; BYTE $0x00 // leaq $16859(%rip), %rdi /* _Digits(%rip) */ + LONG $0x7704b60f // movzbl (%rdi,%rsi,2), %eax + LONG $0x775cb60f; BYTE $0x01 // movzbl $1(%rdi,%rsi,2), %ebx + LONG $0x01478841 // movb %al, $1(%r15) + LONG $0x025f8841 // movb %bl, $2(%r15) + LONG $0x000004e9; BYTE $0x00 // jmp LBB36_66, $4(%rip) + +LBB36_65: + WORD $0x3004 // addb $48, %al + WORD $0x0288 // movb %al, (%rdx) + +LBB36_66: + WORD $0x294d; BYTE $0xc1 // subq %r8, %r9 + WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 + LONG $0x000001be; BYTE $0x00 // movl $1, %esi + WORD $0x294c; BYTE $0xc6 // subq %r8, %rsi + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_67: + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x093c8041; BYTE $0x30 // cmpb $48, (%r9,%rcx) + LONG $0xff498d4d // leaq $-1(%r9), %r9 + LONG $0xffee840f; WORD $0xffff // je LBB36_67, $-18(%rip) + WORD $0x8841; BYTE $0x07 // movb %al, (%r15) + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x00458c0f; WORD $0x0000 // jl LBB36_72, $69(%rip) + LONG $0x09048d49 // leaq (%r9,%rcx), %rax + LONG $0x02c08348 // addq $2, %rax + WORD $0x02c6; BYTE $0x2e // movb $46, (%rdx) + WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00418e0f; WORD $0x0000 // jle LBB36_73, $65(%rip) + +LBB36_70: + WORD $0xff41; BYTE $0xca // decl %r10d + LONG $0x2b0140c6 // movb $43, $1(%rax) + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0x0043820f; WORD $0x0000 // jb LBB36_74, $67(%rip) + +LBB36_71: + WORD $0x6348; BYTE $0xc9 // movslq %ecx, %rcx + LONG $0x5a158d48; WORD $0x0041; BYTE $0x00 // leaq $16730(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x02488966 // movw %cx, $2(%rax) + LONG $0x04c08348 // addq $4, %rax + LONG $0x00097ae9; BYTE $0x00 // jmp LBB36_92, $2426(%rip) + +LBB36_72: + LONG $0x09048d49 // leaq (%r9,%rcx), %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0xffbf8f0f; WORD $0xffff // jg LBB36_70, $-65(%rip) + +LBB36_73: + LONG $0x2d0140c6 // movb $45, $1(%rax) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + WORD $0x2944; BYTE $0xd1 // subl %r10d, %ecx + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0xffbd830f; WORD $0xffff // jae LBB36_71, $-67(%rip) + +LBB36_74: + WORD $0xc180; BYTE $0x30 // addb $48, %cl + WORD $0x4888; BYTE $0x02 // movb %cl, $2(%rax) + LONG $0x03c08348 // addq $3, %rax + LONG $0x000943e9; BYTE $0x00 // jmp LBB36_92, $2371(%rip) + +LBB36_33: + WORD $0xd341; BYTE $0xef // shrl %cl, %r15d + LONG $0xa0ff8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r15d + LONG $0x01a8820f; WORD $0x0000 // jb LBB36_50, $424(%rip) + LONG $0x80ff8141; WORD $0x9896; BYTE $0x00 // cmpl $10000000, %r15d + LONG $0x000008b8; BYTE $0x00 // movl $8, %eax + LONG $0x00d88348 // sbbq $0, %rax + LONG $0x40ff8141; WORD $0x0f42; BYTE $0x00 // cmpl $1000000, %r15d + LONG $0x000006b9; BYTE $0x00 // movl $6, %ecx + LONG $0xc8430f48 // cmovaeq %rax, %rcx + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx + +LBB36_35: + WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax + LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx + LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0xd8f0c269; WORD $0xffff // imull $-10000, %edx, %eax + WORD $0x0144; BYTE $0xf8 // addl %r15d, %eax + LONG $0x1ff06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rsi + LONG $0x25eec148 // shrq $37, %rsi + WORD $0xde6b; BYTE $0x64 // imull $100, %esi, %ebx + WORD $0xd829 // subl %ebx, %eax + LONG $0xaf1d8d48; WORD $0x0040; BYTE $0x00 // leaq $16559(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4304b70f // movzwl (%rbx,%rax,2), %eax + LONG $0xfe418966 // movw %ax, $-2(%rcx) + LONG $0x7304b70f // movzwl (%rbx,%rsi,2), %eax + LONG $0xfc418966 // movw %ax, $-4(%rcx) + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xfcc18348 // addq $-4, %rcx + WORD $0x8941; BYTE $0xd7 // movl %edx, %r15d + LONG $0x64ff8341 // cmpl $100, %r15d + LONG $0x0171830f; WORD $0x0000 // jae LBB36_54, $369(%rip) + LONG $0x0001a8e9; BYTE $0x00 // jmp LBB36_56, $424(%rip) + +LBB36_36: + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x04dc8f0f; WORD $0x0000 // jg LBB36_102, $1244(%rip) + LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) + LONG $0x02c78349 // addq $2, %r15 + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x04c9890f; WORD $0x0000 // jns LBB36_102, $1225(%rip) + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + WORD $0xf741; BYTE $0xd6 // notl %r14d + WORD $0x2945; BYTE $0xde // subl %r11d, %r14d + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x7ffe8341 // cmpl $127, %r14d + LONG $0x049d820f; WORD $0x0000 // jb LBB36_100, $1181(%rip) + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + LONG $0x80e18348 // andq $-128, %rcx + LONG $0x80518d48 // leaq $-128(%rcx), %rdx + WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 + LONG $0x07edc149 // shrq $7, %r13 + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x8945; BYTE $0xef // movl %r13d, %r15d + LONG $0x03e78341 // andl $3, %r15d + LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdx + LONG $0x036a830f; WORD $0x0000 // jae LBB36_94, $874(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x00040de9; BYTE $0x00 // jmp LBB36_96, $1037(%rip) + +LBB36_41: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0xfdac820f; WORD $0xffff // jb LBB36_30, $-596(%rip) + +LBB36_42: + WORD $0xff48; BYTE $0xca // decq %rdx + LONG $0x03358d4c; WORD $0x0040; BYTE $0x00 // leaq $16387(%rip), %r14 /* _Digits(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_43: + WORD $0xc689 // movl %eax, %esi + LONG $0x1ff66948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %rsi + LONG $0x25eec148 // shrq $37, %rsi + WORD $0xfe6b; BYTE $0x64 // imull $100, %esi, %edi + WORD $0xc389 // movl %eax, %ebx + WORD $0xfb29 // subl %edi, %ebx + LONG $0x3cb70f41; BYTE $0x5e // movzwl (%r14,%rbx,2), %edi + LONG $0xff7a8966 // movw %di, $-1(%rdx) + LONG $0xfec28348 // addq $-2, %rdx + LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax + WORD $0xf089 // movl %esi, %eax + LONG $0xffd2870f; WORD $0xffff // ja LBB36_43, $-46(%rip) + +LBB36_44: + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0x0022820f; WORD $0x0000 // jb LBB36_46, $34(%rip) + WORD $0xf089 // movl %esi, %eax + LONG $0xc0158d48; WORD $0x003f; BYTE $0x00 // leaq $16320(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4204b70f // movzwl (%rdx,%rax,2), %eax + LONG $0x07894166 // movw %ax, (%r15) + WORD $0x014d; BYTE $0xdf // addq %r11, %r15 + WORD $0x3945; BYTE $0xd4 // cmpl %r10d, %r12d + LONG $0x0018820f; WORD $0x0000 // jb LBB36_47, $24(%rip) + LONG $0x0002e6e9; BYTE $0x00 // jmp LBB36_91, $742(%rip) + +LBB36_46: + LONG $0x30c68040 // addb $48, %sil + WORD $0x8841; BYTE $0x37 // movb %sil, (%r15) + WORD $0x014d; BYTE $0xdf // addq %r11, %r15 + WORD $0x3945; BYTE $0xd4 // cmpl %r10d, %r12d + LONG $0x02d3830f; WORD $0x0000 // jae LBB36_91, $723(%rip) + +LBB36_47: + LONG $0x29048d4b // leaq (%r9,%r13), %rax + LONG $0x00148d49 // leaq (%r8,%rax), %rdx + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + WORD $0x394c; BYTE $0xda // cmpq %r11, %rdx + LONG $0xda470f4c // cmovaq %rdx, %r11 + WORD $0x014c; BYTE $0xc0 // addq %r8, %rax + WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 + LONG $0x10fb8349 // cmpq $16, %r11 + LONG $0x029f820f; WORD $0x0000 // jb LBB36_90, $671(%rip) + LONG $0x80fb8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r11 + LONG $0x00cf830f; WORD $0x0000 // jae LBB36_75, $207(%rip) + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x000211e9; BYTE $0x00 // jmp LBB36_84, $529(%rip) + +LBB36_50: + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x0aff8341 // cmpl $10, %r15d + LONG $0x0021820f; WORD $0x0000 // jb LBB36_53, $33(%rip) + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + LONG $0x64ff8341 // cmpl $100, %r15d + LONG $0x0012820f; WORD $0x0000 // jb LBB36_53, $18(%rip) + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + LONG $0xe7ff8141; WORD $0x0003; BYTE $0x00 // cmpl $999, %r15d + LONG $0x022b870f; WORD $0x0000 // ja LBB36_87, $555(%rip) + +LBB36_53: + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + LONG $0x64ff8341 // cmpl $100, %r15d + LONG $0x003c820f; WORD $0x0000 // jb LBB36_56, $60(%rip) + +LBB36_54: + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0x10058d4c; WORD $0x003f; BYTE $0x00 // leaq $16144(%rip), %r8 /* _Digits(%rip) */ + + // .p2align 4, 0x90 +LBB36_55: + WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx + WORD $0x8944; BYTE $0xfe // movl %r15d, %esi + LONG $0x1ffe694c; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %r15 + LONG $0x25efc149 // shrq $37, %r15 + LONG $0x64f76b41 // imull $100, %r15d, %esi + WORD $0xda89 // movl %ebx, %edx + WORD $0xf229 // subl %esi, %edx + LONG $0x14b70f41; BYTE $0x50 // movzwl (%r8,%rdx,2), %edx + LONG $0xff518966 // movw %dx, $-1(%rcx) + LONG $0xfec18348 // addq $-2, %rcx + LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx + LONG $0xffce870f; WORD $0xffff // ja LBB36_55, $-50(%rip) + +LBB36_56: + LONG $0x0aff8341 // cmpl $10, %r15d + LONG $0x001a820f; WORD $0x0000 // jb LBB36_58, $26(%rip) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + LONG $0xca158d48; WORD $0x003e; BYTE $0x00 // leaq $16074(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x4d894166; BYTE $0x00 // movw %cx, (%r13) + WORD $0xf829 // subl %edi, %eax + LONG $0x0006eee9; BYTE $0x00 // jmp LBB36_93, $1774(%rip) + +LBB36_58: + LONG $0x30c78041 // addb $48, %r15b + LONG $0x007d8845 // movb %r15b, (%r13) + WORD $0xf829 // subl %edi, %eax + LONG $0x0006dfe9; BYTE $0x00 // jmp LBB36_93, $1759(%rip) + +LBB36_59: + LONG $0x0004b841; WORD $0x0000 // movl $4, %r8d + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0xfbc5820f; WORD $0xffff // jb LBB36_32, $-1083(%rip) + LONG $0xfffc66e9; BYTE $0xff // jmp LBB36_61, $-922(%rip) + +LBB36_75: + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0x80e28349 // andq $-128, %r10 + LONG $0x80428d49 // leaq $-128(%r10), %rax + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + LONG $0x07eac148 // shrq $7, %rdx + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x8941; BYTE $0xd6 // movl %edx, %r14d + LONG $0x03e68341 // andl $3, %r14d + LONG $0x01803d48; WORD $0x0000 // cmpq $384, %rax + LONG $0x0007830f; WORD $0x0000 // jae LBB36_77, $7(%rip) + WORD $0xf631 // xorl %esi, %esi + LONG $0x0000b5e9; BYTE $0x00 // jmp LBB36_79, $181(%rip) + +LBB36_77: + LONG $0xfce28348 // andq $-4, %rdx + LONG $0x01048d4b // leaq (%r9,%r8), %rax + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + LONG $0x01e00548; WORD $0x0000 // addq $480, %rax + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff849056ffdc5 // vmovdqa $-1975(%rip), %ymm0 /* LCPI36_0(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_78: + QUAD $0xfffe2030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rax,%rsi) + QUAD $0xfffe4030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rax,%rsi) + QUAD $0xfffe6030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rax,%rsi) + QUAD $0xfffe8030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rax,%rsi) + QUAD $0xfffea030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rax,%rsi) + QUAD $0xfffec030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rax,%rsi) + QUAD $0xfffee030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rax,%rsi) + QUAD $0xffff0030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rax,%rsi) + QUAD $0xffff2030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rax,%rsi) + QUAD $0xffff4030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rax,%rsi) + QUAD $0xffff6030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rax,%rsi) + LONG $0x447ffec5; WORD $0x8030 // vmovdqu %ymm0, $-128(%rax,%rsi) + LONG $0x447ffec5; WORD $0xa030 // vmovdqu %ymm0, $-96(%rax,%rsi) + LONG $0x447ffec5; WORD $0xc030 // vmovdqu %ymm0, $-64(%rax,%rsi) + LONG $0x447ffec5; WORD $0xe030 // vmovdqu %ymm0, $-32(%rax,%rsi) + LONG $0x047ffec5; BYTE $0x30 // vmovdqu %ymm0, (%rax,%rsi) + LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq $512, %rsi + LONG $0xfcc28348 // addq $-4, %rdx + LONG $0xff6f850f; WORD $0xffff // jne LBB36_78, $-145(%rip) + +LBB36_79: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x004a840f; WORD $0x0000 // je LBB36_82, $74(%rip) + WORD $0x014c; BYTE $0xce // addq %r9, %rsi + WORD $0x014c; BYTE $0xc6 // addq %r8, %rsi + LONG $0x2e048d4a // leaq (%rsi,%r13), %rax + LONG $0x60c08348 // addq $96, %rax + LONG $0x07e6c149 // shlq $7, %r14 + WORD $0xd231 // xorl %edx, %edx + QUAD $0xfffff78a056ffdc5 // vmovdqa $-2166(%rip), %ymm0 /* LCPI36_0(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB36_81: + LONG $0x447ffec5; WORD $0xa010 // vmovdqu %ymm0, $-96(%rax,%rdx) + LONG $0x447ffec5; WORD $0xc010 // vmovdqu %ymm0, $-64(%rax,%rdx) + LONG $0x447ffec5; WORD $0xe010 // vmovdqu %ymm0, $-32(%rax,%rdx) + LONG $0x047ffec5; BYTE $0x10 // vmovdqu %ymm0, (%rax,%rdx) + LONG $0x80ea8348 // subq $-128, %rdx + WORD $0x3949; BYTE $0xd6 // cmpq %rdx, %r14 + LONG $0xffdc850f; WORD $0xffff // jne LBB36_81, $-36(%rip) + +LBB36_82: + WORD $0x394d; BYTE $0xd3 // cmpq %r10, %r11 + LONG $0x0092840f; WORD $0x0000 // je LBB36_91, $146(%rip) + LONG $0x70c3f641 // testb $112, %r11b + LONG $0x0071840f; WORD $0x0000 // je LBB36_89, $113(%rip) + +LBB36_84: + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + LONG $0xf0e08348 // andq $-16, %rax + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x014d; BYTE $0xd1 // addq %r10, %r9 + WORD $0x014d; BYTE $0xc1 // addq %r8, %r9 + WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x294c; BYTE $0xd2 // subq %r10, %rdx + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff746056ff9c5 // vmovdqa $-2234(%rip), %xmm0 /* LCPI36_1(%rip) */ + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB36_85: + LONG $0x7f7ac1c4; WORD $0x3104 // vmovdqu %xmm0, (%r9,%rsi) + LONG $0x10c68348 // addq $16, %rsi + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0xffed850f; WORD $0xffff // jne LBB36_85, $-19(%rip) + WORD $0x3949; BYTE $0xc3 // cmpq %rax, %r11 + LONG $0x0034850f; WORD $0x0000 // jne LBB36_90, $52(%rip) + LONG $0x00003ee9; BYTE $0x00 // jmp LBB36_91, $62(%rip) + +LBB36_87: + LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + LONG $0x00d98348 // sbbq $0, %rcx + LONG $0x05c18348 // addq $5, %rcx + LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d + LONG $0xfc01830f; WORD $0xffff // jae LBB36_35, $-1023(%rip) + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xfffdbee9; BYTE $0xff // jmp LBB36_54, $-578(%rip) + +LBB36_89: + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_90: + WORD $0x01c6; BYTE $0x30 // movb $48, (%rcx) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x394c; BYTE $0xf9 // cmpq %r15, %rcx + LONG $0xfff1820f; WORD $0xffff // jb LBB36_90, $-15(%rip) + +LBB36_91: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0x0004eae9; BYTE $0x00 // jmp LBB36_92, $1258(%rip) + +LBB36_94: + LONG $0xfce58349 // andq $-4, %r13 + LONG $0x39348d49 // leaq (%r9,%rdi), %rsi + LONG $0xe2c68148; WORD $0x0001; BYTE $0x00 // addq $482, %rsi + WORD $0xd231 // xorl %edx, %edx + QUAD $0xfffff6a0056ffdc5 // vmovdqa $-2400(%rip), %ymm0 /* LCPI36_0(%rip) */ + +LBB36_95: + QUAD $0xfffe2016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rsi,%rdx) + QUAD $0xfffe4016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rsi,%rdx) + QUAD $0xfffe6016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rsi,%rdx) + QUAD $0xfffe8016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rsi,%rdx) + QUAD $0xfffea016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rsi,%rdx) + QUAD $0xfffec016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rsi,%rdx) + QUAD $0xfffee016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rsi,%rdx) + QUAD $0xffff0016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rsi,%rdx) + QUAD $0xffff2016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rsi,%rdx) + QUAD $0xffff4016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rsi,%rdx) + QUAD $0xffff6016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rsi,%rdx) + LONG $0x447ffec5; WORD $0x8016 // vmovdqu %ymm0, $-128(%rsi,%rdx) + LONG $0x447ffec5; WORD $0xa016 // vmovdqu %ymm0, $-96(%rsi,%rdx) + LONG $0x447ffec5; WORD $0xc016 // vmovdqu %ymm0, $-64(%rsi,%rdx) + LONG $0x447ffec5; WORD $0xe016 // vmovdqu %ymm0, $-32(%rsi,%rdx) + LONG $0x047ffec5; BYTE $0x16 // vmovdqu %ymm0, (%rsi,%rdx) + LONG $0x00c28148; WORD $0x0002; BYTE $0x00 // addq $512, %rdx + LONG $0xfcc58349 // addq $-4, %r13 + LONG $0xff6f850f; WORD $0xffff // jne LBB36_95, $-145(%rip) + +LBB36_96: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + WORD $0x8949; BYTE $0xfd // movq %rdi, %r13 + LONG $0x003c840f; WORD $0x0000 // je LBB36_99, $60(%rip) + WORD $0x014c; BYTE $0xca // addq %r9, %rdx + WORD $0x014c; BYTE $0xea // addq %r13, %rdx + LONG $0x62c28348 // addq $98, %rdx + LONG $0x07e7c149 // shlq $7, %r15 + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff5eb056ffdc5 // vmovdqa $-2581(%rip), %ymm0 /* LCPI36_0(%rip) */ + +LBB36_98: + LONG $0x447ffec5; WORD $0xa032 // vmovdqu %ymm0, $-96(%rdx,%rsi) + LONG $0x447ffec5; WORD $0xc032 // vmovdqu %ymm0, $-64(%rdx,%rsi) + LONG $0x447ffec5; WORD $0xe032 // vmovdqu %ymm0, $-32(%rdx,%rsi) + LONG $0x047ffec5; BYTE $0x32 // vmovdqu %ymm0, (%rdx,%rsi) + LONG $0x80ee8348 // subq $-128, %rsi + WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 + LONG $0xffdc850f; WORD $0xffff // jne LBB36_98, $-36(%rip) + +LBB36_99: + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x0017840f; WORD $0x0000 // je LBB36_102, $23(%rip) + +LBB36_100: + WORD $0x0144; BYTE $0xd1 // addl %r10d, %ecx + WORD $0xd9f7 // negl %ecx + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_101: + LONG $0x3007c641 // movb $48, (%r15) + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xc9ff // decl %ecx + LONG $0xfff1850f; WORD $0xffff // jne LBB36_101, $-15(%rip) + +LBB36_102: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0x005f820f; WORD $0x0000 // jb LBB36_105, $95(%rip) + WORD $0xc289 // movl %eax, %edx + LONG $0xb71759bb; BYTE $0xd1 // movl $3518437209, %ebx + LONG $0xdaaf0f48 // imulq %rdx, %rbx + LONG $0x2debc148 // shrq $45, %rbx + LONG $0xd8f0d369; WORD $0xffff // imull $-10000, %ebx, %edx + WORD $0xc201 // addl %eax, %edx + LONG $0x01c3840f; WORD $0x0000 // je LBB36_107, $451(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf06b; BYTE $0x64 // imull $100, %eax, %esi + WORD $0xf229 // subl %esi, %edx + LONG $0x59358d48; WORD $0x003b; BYTE $0x00 // leaq $15193(%rip), %rsi /* _Digits(%rip) */ + LONG $0x5614b70f // movzwl (%rsi,%rdx,2), %edx + LONG $0x57894166; BYTE $0xfe // movw %dx, $-2(%r15) + LONG $0x4604b70f // movzwl (%rsi,%rax,2), %eax + LONG $0x47894166; BYTE $0xfc // movw %ax, $-4(%r15) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0xfc578d49 // leaq $-4(%r15), %rdx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0x0018830f; WORD $0x0000 // jae LBB36_109, $24(%rip) + +LBB36_106: + WORD $0xd889 // movl %ebx, %eax + LONG $0x00004ee9; BYTE $0x00 // jmp LBB36_111, $78(%rip) + +LBB36_105: + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0xc389 // movl %eax, %ebx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0xffe8820f; WORD $0xffff // jb LBB36_106, $-24(%rip) + +LBB36_109: + WORD $0xff48; BYTE $0xca // decq %rdx + LONG $0x15358d48; WORD $0x003b; BYTE $0x00 // leaq $15125(%rip), %rsi /* _Digits(%rip) */ + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_110: + WORD $0xd889 // movl %ebx, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi + WORD $0xd989 // movl %ebx, %ecx + WORD $0xf929 // subl %edi, %ecx + LONG $0x4e0cb70f // movzwl (%rsi,%rcx,2), %ecx + LONG $0xff4a8966 // movw %cx, $-1(%rdx) + LONG $0xfec28348 // addq $-2, %rdx + LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx + WORD $0xc389 // movl %eax, %ebx + LONG $0xffd2870f; WORD $0xffff // ja LBB36_110, $-46(%rip) + +LBB36_111: + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x0019820f; WORD $0x0000 // jb LBB36_113, $25(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0xcd0d8d48; WORD $0x003a; BYTE $0x00 // leaq $15053(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8966; BYTE $0x01 // movw %ax, (%rcx) + LONG $0x000008e9; BYTE $0x00 // jmp LBB36_114, $8(%rip) + +LBB36_113: + WORD $0x3004 // addb $48, %al + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x0188 // movb %al, (%rcx) + +LBB36_114: + WORD $0x294d; BYTE $0xf7 // subq %r14, %r15 + WORD $0x294d; BYTE $0xf0 // subq %r14, %r8 + WORD $0xff49; BYTE $0xc0 // incq %r8 + LONG $0x1e048d43 // leal (%r14,%r11), %eax + WORD $0xd8f6 // negb %al + LONG $0x33148d43 // leal (%r11,%r14), %edx + WORD $0xdaf7 // negl %edx + LONG $0x332c8d47 // leal (%r11,%r14), %r13d + WORD $0xff41; BYTE $0xcd // decl %r13d + LONG $0x33348d43 // leal (%r11,%r14), %esi + WORD $0xc683; BYTE $0xfe // addl $-2, %esi + WORD $0xc931 // xorl %ecx, %ecx + + // .p2align 4, 0x90 +LBB36_115: + WORD $0xc389 // movl %eax, %ebx + WORD $0x438d; BYTE $0x03 // leal $3(%rbx), %eax + WORD $0xc6ff // incl %esi + LONG $0x0f7c8041; WORD $0x30ff // cmpb $48, $-1(%r15,%rcx) + LONG $0xff498d48 // leaq $-1(%rcx), %rcx + LONG $0xffe9840f; WORD $0xffff // je LBB36_115, $-23(%rip) + LONG $0x0f048d49 // leaq (%r15,%rcx), %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00b28e0f; WORD $0x0000 // jle LBB36_121, $178(%rip) + WORD $0x2945; BYTE $0xf4 // subl %r14d, %r12d + LONG $0x0c3c8d41 // leal (%r12,%rcx), %edi + WORD $0xc7ff // incl %edi + WORD $0x3941; BYTE $0xfa // cmpl %edi, %r10d + LONG $0x002d8d0f; WORD $0x0000 // jge LBB36_122, $45(%rip) + WORD $0x6348; BYTE $0xc2 // movslq %edx, %rax + LONG $0x08348d48 // leaq (%rax,%rcx), %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xf685 // testl %esi, %esi + WORD $0x894d; BYTE $0xcd // movq %r9, %r13 + LONG $0x011a8e0f; WORD $0x0000 // jle LBB36_133, $282(%rip) + WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d + LONG $0xff508d49 // leaq $-1(%r8), %rdx + LONG $0x03fa8348 // cmpq $3, %rdx + LONG $0x009a830f; WORD $0x0000 // jae LBB36_127, $154(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x0000c6e9; BYTE $0x00 // jmp LBB36_130, $198(%rip) + +LBB36_122: + WORD $0x8945; BYTE $0xea // movl %r13d, %r10d + WORD $0x2949; BYTE $0xca // subq %rcx, %r10 + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00648e0f; WORD $0x0000 // jle LBB36_121, $100(%rip) + LONG $0x331c8d43 // leal (%r11,%r14), %ebx + WORD $0xc383; BYTE $0xfe // addl $-2, %ebx + WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx + WORD $0xd231 // xorl %edx, %edx + WORD $0xfb83; BYTE $0x7f // cmpl $127, %ebx + WORD $0x894d; BYTE $0xcd // movq %r9, %r13 + LONG $0x0223820f; WORD $0x0000 // jb LBB36_140, $547(%rip) + WORD $0x0145; BYTE $0xde // addl %r11d, %r14d + LONG $0xfec68341 // addl $-2, %r14d + WORD $0x2949; BYTE $0xce // subq %rcx, %r14 + WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d + WORD $0xff49; BYTE $0xc3 // incq %r11 + WORD $0x894c; BYTE $0xda // movq %r11, %rdx + LONG $0x80e28348 // andq $-128, %rdx + LONG $0xd07d8b48 // movq $-48(%rbp), %rdi + WORD $0x014c; BYTE $0xc7 // addq %r8, %rdi + WORD $0xf089 // movl %esi, %eax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x80e08348 // andq $-128, %rax + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + LONG $0x80728d48 // leaq $-128(%rdx), %rsi + WORD $0x8949; BYTE $0xf0 // movq %rsi, %r8 + LONG $0x07e8c149 // shrq $7, %r8 + WORD $0xff49; BYTE $0xc0 // incq %r8 + LONG $0x80fe8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rsi + LONG $0x00ae830f; WORD $0x0000 // jae LBB36_134, $174(%rip) + WORD $0xf631 // xorl %esi, %esi + LONG $0x000163e9; BYTE $0x00 // jmp LBB36_136, $355(%rip) + +LBB36_121: + WORD $0x894d; BYTE $0xcd // movq %r9, %r13 + LONG $0x0001e0e9; BYTE $0x00 // jmp LBB36_92, $480(%rip) + +LBB36_107: + LONG $0x0004be41; WORD $0x0000 // movl $4, %r14d + LONG $0xfc578d49 // leaq $-4(%r15), %rdx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0xfe65820f; WORD $0xffff // jb LBB36_106, $-411(%rip) + LONG $0xfffe78e9; BYTE $0xff // jmp LBB36_109, $-392(%rip) + +LBB36_127: + WORD $0xe683; BYTE $0xfc // andl $-4, %esi + WORD $0xf748; BYTE $0xde // negq %rsi + WORD $0xd231 // xorl %edx, %edx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_128: + LONG $0x173c8d49 // leaq (%r15,%rdx), %rdi + LONG $0xfd39448b // movl $-3(%rcx,%rdi), %eax + LONG $0xfe394489 // movl %eax, $-2(%rcx,%rdi) + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffe7850f; WORD $0xffff // jne LBB36_128, $-25(%rip) + WORD $0xf748; BYTE $0xda // negq %rdx + +LBB36_130: + LONG $0x03c0f641 // testb $3, %r8b + LONG $0x0032840f; WORD $0x0000 // je LBB36_133, $50(%rip) + WORD $0xb60f; BYTE $0xc3 // movzbl %bl, %eax + WORD $0xe083; BYTE $0x03 // andl $3, %eax + WORD $0xf748; BYTE $0xd8 // negq %rax + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi + WORD $0xd231 // xorl %edx, %edx + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_132: + LONG $0x163c8d48 // leaq (%rsi,%rdx), %rdi + LONG $0x391cb60f // movzbl (%rcx,%rdi), %ebx + LONG $0x01395c88 // movb %bl, $1(%rcx,%rdi) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0xffe8850f; WORD $0xffff // jne LBB36_132, $-24(%rip) + +LBB36_133: + WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + LONG $0x2e0204c6 // movb $46, (%rdx,%rax) + LONG $0x0f048d49 // leaq (%r15,%rcx), %rax + LONG $0x02c08348 // addq $2, %rax + LONG $0x000141e9; BYTE $0x00 // jmp LBB36_92, $321(%rip) + +LBB36_134: + WORD $0x8944; BYTE $0xf3 // movl %r14d, %ebx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x80e38348 // andq $-128, %rbx + LONG $0x80c38348 // addq $-128, %rbx + LONG $0x07ebc148 // shrq $7, %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfce38348 // andq $-4, %rbx + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff2ed056ffdc5 // vmovdqa $-3347(%rip), %ymm0 /* LCPI36_0(%rip) */ + +LBB36_135: + LONG $0x373c8d49 // leaq (%r15,%rsi), %rdi + LONG $0x447ffec5; WORD $0x0139 // vmovdqu %ymm0, $1(%rcx,%rdi) + LONG $0x447ffec5; WORD $0x2139 // vmovdqu %ymm0, $33(%rcx,%rdi) + LONG $0x447ffec5; WORD $0x4139 // vmovdqu %ymm0, $65(%rcx,%rdi) + LONG $0x447ffec5; WORD $0x6139 // vmovdqu %ymm0, $97(%rcx,%rdi) + QUAD $0x00008139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $129(%rcx,%rdi) + QUAD $0x0000a139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $161(%rcx,%rdi) + QUAD $0x0000c139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $193(%rcx,%rdi) + QUAD $0x0000e139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $225(%rcx,%rdi) + QUAD $0x00010139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $257(%rcx,%rdi) + QUAD $0x00012139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $289(%rcx,%rdi) + QUAD $0x00014139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $321(%rcx,%rdi) + QUAD $0x00016139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $353(%rcx,%rdi) + QUAD $0x00018139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $385(%rcx,%rdi) + QUAD $0x0001a139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $417(%rcx,%rdi) + QUAD $0x0001c139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $449(%rcx,%rdi) + QUAD $0x0001e139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $481(%rcx,%rdi) + LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq $512, %rsi + LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xff67850f; WORD $0xffff // jne LBB36_135, $-153(%rip) + +LBB36_136: + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0x03c0f641 // testb $3, %r8b + LONG $0x005a840f; WORD $0x0000 // je LBB36_139, $90(%rip) + WORD $0xff41; BYTE $0xc6 // incl %r14d + LONG $0x80e68141; WORD $0x0001; BYTE $0x00 // andl $384, %r14d + LONG $0x80c68341 // addl $-128, %r14d + LONG $0x07eec141 // shrl $7, %r14d + WORD $0xfe41; BYTE $0xc6 // incb %r14b + LONG $0xc6b60f45 // movzbl %r14b, %r8d + LONG $0x03e08341 // andl $3, %r8d + LONG $0x07e0c149 // shlq $7, %r8 + WORD $0x014c; BYTE $0xfe // addq %r15, %rsi + LONG $0x61c68348 // addq $97, %rsi + WORD $0xdb31 // xorl %ebx, %ebx + QUAD $0xfffff215056ffdc5 // vmovdqa $-3563(%rip), %ymm0 /* LCPI36_0(%rip) */ + +LBB36_138: + LONG $0x1e3c8d48 // leaq (%rsi,%rbx), %rdi + LONG $0x447ffec5; WORD $0xa039 // vmovdqu %ymm0, $-96(%rcx,%rdi) + LONG $0x447ffec5; WORD $0xc039 // vmovdqu %ymm0, $-64(%rcx,%rdi) + LONG $0x447ffec5; WORD $0xe039 // vmovdqu %ymm0, $-32(%rcx,%rdi) + LONG $0x047ffec5; BYTE $0x39 // vmovdqu %ymm0, (%rcx,%rdi) + LONG $0x80eb8348 // subq $-128, %rbx + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0xffd8850f; WORD $0xffff // jne LBB36_138, $-40(%rip) + +LBB36_139: + WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 + LONG $0x0015840f; WORD $0x0000 // je LBB36_92, $21(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB36_140: + WORD $0x00c6; BYTE $0x30 // movb $48, (%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0xc2ff // incl %edx + WORD $0x3944; BYTE $0xd2 // cmpl %r10d, %edx + LONG $0xffef8c0f; WORD $0xffff // jl LBB36_140, $-17(%rip) + +LBB36_92: + WORD $0x2944; BYTE $0xe8 // subl %r13d, %eax + +LBB36_93: + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB36_141: + WORD $0xc031 // xorl %eax, %eax + LONG $0xffffe7e9; BYTE $0xff // jmp LBB36_93, $-25(%rip) + +LBB36_142: + LONG $0xd07d8948 // movq %rdi, $-48(%rbp) + LONG $0xff6bb841; WORD $0xffff // movl $-149, %r8d + WORD $0x8941; BYTE $0xc7 // movl %eax, %r15d + LONG $0xfff257e9; BYTE $0xff // jmp LBB36_8, $-3497(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +_format_significand: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x20e8c148 // shrq $32, %rax + LONG $0x001c850f; WORD $0x0000 // jne LBB37_2, $28(%rip) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx + LONG $0x00e3830f; WORD $0x0000 // jae LBB37_8, $227(%rip) + +LBB37_7: + WORD $0xd789 // movl %edx, %edi + LONG $0x000132e9; BYTE $0x00 // jmp LBB37_10, $306(%rip) + +LBB37_2: + QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0x1f00ca69; WORD $0xfa0a // imull $-100000000, %edx, %ecx + WORD $0xf901 // addl %edi, %ecx + LONG $0x00a4840f; WORD $0x0000 // je LBB37_3, $164(%rip) + WORD $0xc889 // movl %ecx, %eax + LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d + LONG $0xc1af0f49 // imulq %r9, %rax + LONG $0x2de8c148 // shrq $45, %rax + LONG $0x2710f869; WORD $0x0000 // imull $10000, %eax, %edi + WORD $0xf929 // subl %edi, %ecx + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xf9af0f49 // imulq %r9, %rdi + LONG $0x2defc148 // shrq $45, %rdi + LONG $0x2710ff69; WORD $0x0000 // imull $10000, %edi, %edi + WORD $0xf829 // subl %edi, %eax + WORD $0xb70f; BYTE $0xf9 // movzwl %cx, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull $5243, %edi, %r9d + LONG $0x11e9c141 // shrl $17, %r9d + LONG $0x64f96b41 // imull $100, %r9d, %edi + WORD $0xf929 // subl %edi, %ecx + LONG $0xd1b70f44 // movzwl %cx, %r10d + WORD $0xb70f; BYTE $0xf8 // movzwl %ax, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x147bff69; WORD $0x0000 // imull $5243, %edi, %edi + WORD $0xefc1; BYTE $0x11 // shrl $17, %edi + WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0xd8b70f44 // movzwl %ax, %r11d + LONG $0xe30d8d48; WORD $0x0036; BYTE $0x00 // leaq $14051(%rip), %rcx /* _Digits(%rip) */ + LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax + LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) + LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax + LONG $0x40894166; BYTE $0xfc // movw %ax, $-4(%r8) + LONG $0x04b70f42; BYTE $0x59 // movzwl (%rcx,%r11,2), %eax + LONG $0x40894166; BYTE $0xfa // movw %ax, $-6(%r8) + LONG $0x7904b70f // movzwl (%rcx,%rdi,2), %eax + LONG $0x40894166; BYTE $0xf8 // movw %ax, $-8(%r8) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0xf8708d4d // leaq $-8(%r8), %r14 + LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx + LONG $0xff38820f; WORD $0xffff // jb LBB37_7, $-200(%rip) + LONG $0x000016e9; BYTE $0x00 // jmp LBB37_8, $22(%rip) + +LBB37_3: + LONG $0x0008b941; WORD $0x0000 // movl $8, %r9d + LONG $0xf8708d4d // leaq $-8(%r8), %r14 + LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx + LONG $0xff1d820f; WORD $0xffff // jb LBB37_7, $-227(%rip) + +LBB37_8: + LONG $0x1759ba41; WORD $0xd1b7 // movl $3518437209, %r10d + LONG $0x811d8d4c; WORD $0x0036; BYTE $0x00 // leaq $13953(%rip), %r11 /* _Digits(%rip) */ + BYTE $0x90 // .p2align 4, 0x90 + +LBB37_9: + WORD $0xd789 // movl %edx, %edi + LONG $0xfaaf0f49 // imulq %r10, %rdi + LONG $0x2defc148 // shrq $45, %rdi + LONG $0xd8f0c769; WORD $0xffff // imull $-10000, %edi, %eax + WORD $0xd001 // addl %edx, %eax + LONG $0x1fd86948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rbx + LONG $0x25ebc148 // shrq $37, %rbx + WORD $0xcb6b; BYTE $0x64 // imull $100, %ebx, %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0x04b70f41; BYTE $0x43 // movzwl (%r11,%rax,2), %eax + LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) + LONG $0x04b70f41; BYTE $0x5b // movzwl (%r11,%rbx,2), %eax + LONG $0x46894166; BYTE $0xfc // movw %ax, $-4(%r14) + LONG $0xfcc68349 // addq $-4, %r14 + LONG $0xe0fffa81; WORD $0x05f5 // cmpl $99999999, %edx + WORD $0xfa89 // movl %edi, %edx + LONG $0xffb8870f; WORD $0xffff // ja LBB37_9, $-72(%rip) + +LBB37_10: + WORD $0xff83; BYTE $0x64 // cmpl $100, %edi + LONG $0x0020830f; WORD $0x0000 // jae LBB37_11, $32(%rip) + WORD $0xff83; BYTE $0x0a // cmpl $10, %edi + LONG $0x004d820f; WORD $0x0000 // jb LBB37_14, $77(%rip) + +LBB37_13: + WORD $0xf889 // movl %edi, %eax + LONG $0x1d0d8d48; WORD $0x0036; BYTE $0x00 // leaq $13853(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) + LONG $0x00003de9; BYTE $0x00 // jmp LBB37_15, $61(%rip) + +LBB37_11: + WORD $0xb70f; BYTE $0xc7 // movzwl %di, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx + WORD $0xcf29 // subl %ecx, %edi + WORD $0xb70f; BYTE $0xcf // movzwl %di, %ecx + LONG $0xf1158d48; WORD $0x0035; BYTE $0x00 // leaq $13809(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x4e894166; BYTE $0xfe // movw %cx, $-2(%r14) + LONG $0xfec68349 // addq $-2, %r14 + WORD $0xc789 // movl %eax, %edi + WORD $0xff83; BYTE $0x0a // cmpl $10, %edi + LONG $0xffb3830f; WORD $0xffff // jae LBB37_13, $-77(%rip) + +LBB37_14: + LONG $0x30c78040 // addb $48, %dil + WORD $0x8840; BYTE $0x3e // movb %dil, (%rsi) + +LBB37_15: + WORD $0x294d; BYTE $0xc8 // subq %r9, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_left_shift: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0xf189 // movl %esi, %ecx + LONG $0x68c16b48 // imulq $104, %rcx, %rax + LONG $0x9a158d48; WORD $0x008f; BYTE $0x00 // leaq $36762(%rip), %rdx /* _LSHIFT_TAB(%rip) */ + LONG $0x10048b44 // movl (%rax,%rdx), %r8d + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0x04c28348 // addq $4, %rdx + LONG $0x10476348 // movslq $16(%rdi), %rax + WORD $0xf631 // xorl %esi, %esi + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0031840f; WORD $0x0000 // je LBB38_6, $49(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB38_1: + LONG $0x321cb60f // movzbl (%rdx,%rsi), %ebx + WORD $0xdb84 // testb %bl, %bl + LONG $0x0025840f; WORD $0x0000 // je LBB38_8, $37(%rip) + LONG $0x311c3841 // cmpb %bl, (%r9,%rsi) + LONG $0x0189850f; WORD $0x0000 // jne LBB38_3, $393(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffde850f; WORD $0xffff // jne LBB38_1, $-34(%rip) + WORD $0xc689 // movl %eax, %esi + +LBB38_6: + LONG $0x00323c80 // cmpb $0, (%rdx,%rsi) + LONG $0x0003840f; WORD $0x0000 // je LBB38_8, $3(%rip) + +LBB38_7: + WORD $0xff41; BYTE $0xc8 // decl %r8d + +LBB38_8: + WORD $0xc085 // testl %eax, %eax + LONG $0x00968e0f; WORD $0x0000 // jle LBB38_22, $150(%rip) + LONG $0x001c8d45 // leal (%r8,%rax), %r11d + WORD $0xc389 // movl %eax, %ebx + WORD $0x634d; BYTE $0xf3 // movslq %r11d, %r14 + WORD $0xff49; BYTE $0xce // decq %r14 + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xd231 // xorl %edx, %edx + QUAD $0xcccccccccccdba49; WORD $0xcccc // movabsq $-3689348814741910323, %r10 + LONG $0x000023e9; BYTE $0x00 // jmp LBB38_10, $35(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB38_11: + WORD $0x3004 // addb $48, %al + LONG $0x31048843 // movb %al, (%r9,%r14) + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + +LBB38_18: + WORD $0xff41; BYTE $0xcb // decl %r11d + WORD $0xff49; BYTE $0xce // decq %r14 + WORD $0xff48; BYTE $0xcb // decq %rbx + LONG $0x01fb8348 // cmpq $1, %rbx + LONG $0x0049860f; WORD $0x0000 // jbe LBB38_12, $73(%rip) + +LBB38_10: + WORD $0x438d; BYTE $0xfe // leal $-2(%rbx), %eax + LONG $0x34be0f49; BYTE $0x01 // movsbq (%r9,%rax), %rsi + LONG $0xd0c68348 // addq $-48, %rsi + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe2 // mulq %r10 + LONG $0x03eac148 // shrq $3, %rdx + LONG $0x12048d48 // leaq (%rdx,%rdx), %rax + LONG $0x803c8d4c // leaq (%rax,%rax,4), %r15 + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x294c; BYTE $0xf8 // subq %r15, %rax + LONG $0x0877394c // cmpq %r14, $8(%rdi) + LONG $0xffb0870f; WORD $0xffff // ja LBB38_11, $-80(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xffb0840f; WORD $0xffff // je LBB38_18, $-80(%rip) + LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) + LONG $0xffffa4e9; BYTE $0xff // jmp LBB38_18, $-92(%rip) + +LBB38_12: + LONG $0x0afe8348 // cmpq $10, %rsi + LONG $0x0070830f; WORD $0x0000 // jae LBB38_13, $112(%rip) + +LBB38_22: + LONG $0x10476348 // movslq $16(%rdi), %rax + WORD $0x6349; BYTE $0xc8 // movslq %r8d, %rcx + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) + LONG $0x08478b48 // movq $8(%rdi), %rax + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x0005870f; WORD $0x0000 // ja LBB38_24, $5(%rip) + WORD $0x4789; BYTE $0x10 // movl %eax, $16(%rdi) + WORD $0xc189 // movl %eax, %ecx + +LBB38_24: + LONG $0x14470144 // addl %r8d, $20(%rdi) + WORD $0xc985 // testl %ecx, %ecx + LONG $0x00318e0f; WORD $0x0000 // jle LBB38_28, $49(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0xc989 // movl %ecx, %ecx + BYTE $0x90 // .p2align 4, 0x90 + +LBB38_26: + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + WORD $0xd689 // movl %edx, %esi + LONG $0x30303c80 // cmpb $48, (%rax,%rsi) + LONG $0x0028850f; WORD $0x0000 // jne LBB38_30, $40(%rip) + WORD $0xc9ff // decl %ecx + WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) + LONG $0x01728d48 // leaq $1(%rdx), %rsi + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x01fe8348 // cmpq $1, %rsi + LONG $0xffda870f; WORD $0xffff // ja LBB38_26, $-38(%rip) + LONG $0x000006e9; BYTE $0x00 // jmp LBB38_29, $6(%rip) + +LBB38_28: + LONG $0x0007850f; WORD $0x0000 // jne LBB38_30, $7(%rip) + +LBB38_29: + LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) + +LBB38_30: + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB38_13: + WORD $0x6349; BYTE $0xf3 // movslq %r11d, %rsi + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x00001be9; BYTE $0x00 // jmp LBB38_14, $27(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB38_15: + WORD $0x3004 // addb $48, %al + WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx + WORD $0x0488; BYTE $0x33 // movb %al, (%rbx,%rsi) + +LBB38_21: + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x09f98348 // cmpq $9, %rcx + LONG $0xff6a860f; WORD $0xffff // jbe LBB38_22, $-150(%rip) + +LBB38_14: + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0xf749; BYTE $0xe2 // mulq %r10 + LONG $0x03eac148 // shrq $3, %rdx + LONG $0x12048d48 // leaq (%rdx,%rdx), %rax + LONG $0x801c8d48 // leaq (%rax,%rax,4), %rbx + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax + LONG $0x08773948 // cmpq %rsi, $8(%rdi) + LONG $0xffc6870f; WORD $0xffff // ja LBB38_15, $-58(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xffc5840f; WORD $0xffff // je LBB38_21, $-59(%rip) + LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) + LONG $0xffffb9e9; BYTE $0xff // jmp LBB38_21, $-71(%rip) + +LBB38_3: + LONG $0xfe898c0f; WORD $0xffff // jl LBB38_7, $-375(%rip) + LONG $0xfffe87e9; BYTE $0xff // jmp LBB38_8, $-377(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_right_shift: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + WORD $0xf189 // movl %esi, %ecx + LONG $0x10478b44 // movl $16(%rdi), %r8d + WORD $0xd231 // xorl %edx, %edx + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0x0000bb41; WORD $0x0000 // movl $0, %r11d + LONG $0xd84f0f45 // cmovgl %r8d, %r11d + WORD $0xc031 // xorl %eax, %eax + LONG $0x90909090 // .p2align 4, 0x90 + +LBB39_1: + WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 + LONG $0x0132840f; WORD $0x0000 // je LBB39_2, $306(%rip) + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + LONG $0x34be0f48; BYTE $0x16 // movsbq (%rsi,%rdx), %rsi + LONG $0x46048d48 // leaq (%rsi,%rax,2), %rax + LONG $0xd0c08348 // addq $-48, %rax + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0xd348; BYTE $0xee // shrq %cl, %rsi + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xffd1840f; WORD $0xffff // je LBB39_1, $-47(%rip) + WORD $0x8941; BYTE $0xd3 // movl %edx, %r11d + +LBB39_7: + WORD $0x578b; BYTE $0x14 // movl $20(%rdi), %edx + WORD $0x2944; BYTE $0xda // subl %r11d, %edx + WORD $0xc2ff // incl %edx + LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 + WORD $0xd349; BYTE $0xe1 // shlq %cl, %r9 + WORD $0x5789; BYTE $0x14 // movl %edx, $20(%rdi) + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3945; BYTE $0xc3 // cmpl %r8d, %r11d + LONG $0x00718d0f; WORD $0x0000 // jge LBB39_10, $113(%rip) + WORD $0x634d; BYTE $0xc3 // movslq %r11d, %r8 + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + BYTE $0x90 // .p2align 4, 0x90 + +LBB39_9: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x214c; BYTE $0xc8 // andq %r9, %rax + WORD $0xc280; BYTE $0x30 // addb $48, %dl + LONG $0x16148842 // movb %dl, (%rsi,%r10) + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + LONG $0x06148d4a // leaq (%rsi,%r8), %rdx + LONG $0x1cbe0f4d; BYTE $0x12 // movsbq (%r10,%rdx), %r11 + LONG $0x105c8d4b; BYTE $0x01 // leaq $1(%r8,%r10), %rbx + WORD $0xff49; BYTE $0xc2 // incq %r10 + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + LONG $0x43048d49 // leaq (%r11,%rax,2), %rax + LONG $0xd0c08348 // addq $-48, %rax + LONG $0x10576348 // movslq $16(%rdi), %rdx + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0xffc38c0f; WORD $0xffff // jl LBB39_9, $-61(%rip) + LONG $0x000025e9; BYTE $0x00 // jmp LBB39_10, $37(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB39_12: + LONG $0x30c68040 // addb $48, %sil + WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx + LONG $0x13348840 // movb %sil, (%rbx,%rdx) + WORD $0xc2ff // incl %edx + WORD $0x8941; BYTE $0xd2 // movl %edx, %r10d + +LBB39_15: + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + +LBB39_10: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x002b840f; WORD $0x0000 // je LBB39_16, $43(%rip) + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0xd348; BYTE $0xee // shrq %cl, %rsi + WORD $0x214c; BYTE $0xc8 // andq %r9, %rax + WORD $0x6349; BYTE $0xd2 // movslq %r10d, %rdx + LONG $0x08573948 // cmpq %rdx, $8(%rdi) + LONG $0xffca870f; WORD $0xffff // ja LBB39_12, $-54(%rip) + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xffd1840f; WORD $0xffff // je LBB39_15, $-47(%rip) + LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) + LONG $0xffffc5e9; BYTE $0xff // jmp LBB39_15, $-59(%rip) + +LBB39_16: + LONG $0x10578944 // movl %r10d, $16(%rdi) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00758e0f; WORD $0x0000 // jle LBB39_20, $117(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0x9090 // .p2align 4, 0x90 + +LBB39_18: + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + WORD $0xd689 // movl %edx, %esi + LONG $0x30303c80 // cmpb $48, (%rax,%rsi) + LONG $0x0063850f; WORD $0x0000 // jne LBB39_22, $99(%rip) + WORD $0xc9ff // decl %ecx + WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) + LONG $0x01728d48 // leaq $1(%rdx), %rsi + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x01fe8348 // cmpq $1, %rsi + LONG $0xffda870f; WORD $0xffff // ja LBB39_18, $-38(%rip) + LONG $0x00004be9; BYTE $0x00 // jmp LBB39_21, $75(%rip) + +LBB39_2: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x004c840f; WORD $0x0000 // je LBB39_23, $76(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xfed3850f; WORD $0xffff // jne LBB39_7, $-301(%rip) + +LBB39_4: + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + WORD $0xff41; BYTE $0xc3 // incl %r11d + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffe7840f; WORD $0xffff // je LBB39_4, $-25(%rip) + LONG $0xfffeb5e9; BYTE $0xff // jmp LBB39_7, $-331(%rip) + +LBB39_20: + LONG $0x0003840f; WORD $0x0000 // je LBB39_21, $3(%rip) + +LBB39_22: + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB39_21: + LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB39_23: + LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl $0, $16(%rdi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 + +LCPI40_0: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI40_1: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + + // .p2align 4, 0x90 +_advance_string_default: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x087f8b4c // movq $8(%rdi), %r15 + WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 + LONG $0x02e9840f; WORD $0x0000 // je LBB40_17, $745(%rip) + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + LONG $0x40ff8349 // cmpq $64, %r15 + LONG $0x0172820f; WORD $0x0000 // jb LBB40_18, $370(%rip) + WORD $0x8948; BYTE $0xf7 // movq %rsi, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + QUAD $0xffffff7a056ffdc5 // vmovdqa $-134(%rip), %ymm0 /* LCPI40_0(%rip) */ + QUAD $0xffffff920d6ffdc5 // vmovdqa $-110(%rip), %ymm1 /* LCPI40_1(%rip) */ + QUAD $0xaaaaaaaaaaaaba49; WORD $0xaaaa // movabsq $-6148914691236517206, %r10 + QUAD $0x555555555555bb49; WORD $0x5555 // movabsq $6148914691236517205, %r11 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB40_3: + LONG $0x6f7ec1c4; WORD $0x3114 // vmovdqu (%r9,%rsi), %ymm2 + LONG $0x6f7ec1c4; WORD $0x315c; BYTE $0x20 // vmovdqu $32(%r9,%rsi), %ymm3 + LONG $0xe074edc5 // vpcmpeqb %ymm0, %ymm2, %ymm4 + LONG $0xe4d77dc5 // vpmovmskb %ymm4, %r12d + LONG $0xe074e5c5 // vpcmpeqb %ymm0, %ymm3, %ymm4 + LONG $0xccd7fdc5 // vpmovmskb %ymm4, %ecx + LONG $0xd174edc5 // vpcmpeqb %ymm1, %ymm2, %ymm2 + LONG $0xc2d7fdc5 // vpmovmskb %ymm2, %eax + LONG $0xd174e5c5 // vpcmpeqb %ymm1, %ymm3, %ymm2 + LONG $0xdad7fdc5 // vpmovmskb %ymm2, %ebx + LONG $0x20e1c148 // shlq $32, %rcx + WORD $0x0949; BYTE $0xcc // orq %rcx, %r12 + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x0948; BYTE $0xd8 // orq %rbx, %rax + LONG $0x0030850f; WORD $0x0000 // jne LBB40_7, $48(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x003b850f; WORD $0x0000 // jne LBB40_9, $59(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x006d850f; WORD $0x0000 // jne LBB40_10, $109(%rip) + +LBB40_6: + LONG $0xc0c78349 // addq $-64, %r15 + LONG $0xc0c78348 // addq $-64, %rdi + LONG $0x40c68348 // addq $64, %rsi + LONG $0x3fff8349 // cmpq $63, %r15 + LONG $0xff94870f; WORD $0xffff // ja LBB40_3, $-108(%rip) + LONG $0x000067e9; BYTE $0x00 // jmp LBB40_12, $103(%rip) + +LBB40_7: + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x000a850f; WORD $0x0000 // jne LBB40_9, $10(%rip) + LONG $0xc0bc0f4c // bsfq %rax, %r8 + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + +LBB40_9: + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + LONG $0x092c8d4c // leaq (%rcx,%rcx), %r13 + WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 + WORD $0x894c; BYTE $0xeb // movq %r13, %rbx + WORD $0xf748; BYTE $0xd3 // notq %rbx + WORD $0x2148; BYTE $0xc3 // andq %rax, %rbx + WORD $0x214c; BYTE $0xd3 // andq %r10, %rbx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xc6920f41 // setb %r14b + WORD $0x0148; BYTE $0xdb // addq %rbx, %rbx + WORD $0x314c; BYTE $0xdb // xorq %r11, %rbx + WORD $0x214c; BYTE $0xeb // andq %r13, %rbx + WORD $0xf748; BYTE $0xd3 // notq %rbx + WORD $0x2149; BYTE $0xdc // andq %rbx, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0xff93840f; WORD $0xffff // je LBB40_6, $-109(%rip) + +LBB40_10: + LONG $0xc4bc0f49 // bsfq %r12, %rax + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + +LBB40_11: + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB40_12: + WORD $0x014c; BYTE $0xce // addq %r9, %rsi + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x00c2820f; WORD $0x0000 // jb LBB40_23, $194(%rip) + +LBB40_13: + LONG $0x066ffec5 // vmovdqu (%rsi), %ymm0 + QUAD $0xfffffe5f0d74fdc5 // vpcmpeqb $-417(%rip), %ymm0, %ymm1 /* LCPI40_0(%rip) */ + LONG $0xf9d7fdc5 // vpmovmskb %ymm1, %edi + QUAD $0xfffffe730574fdc5 // vpcmpeqb $-397(%rip), %ymm0, %ymm0 /* LCPI40_1(%rip) */ + LONG $0xc0d7fdc5 // vpmovmskb %ymm0, %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x0043850f; WORD $0x0000 // jne LBB40_19, $67(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0054850f; WORD $0x0000 // jne LBB40_21, $84(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0081840f; WORD $0x0000 // je LBB40_22, $129(%rip) + +LBB40_16: + LONG $0xc7bc0f48 // bsfq %rdi, %rax + WORD $0x294c; BYTE $0xce // subq %r9, %rsi + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xffff9ae9; BYTE $0xff // jmp LBB40_11, $-102(%rip) + +LBB40_18: + WORD $0x014c; BYTE $0xce // addq %r9, %rsi + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0xff9e830f; WORD $0xffff // jae LBB40_13, $-98(%rip) + LONG $0x00005be9; BYTE $0x00 // jmp LBB40_23, $91(%rip) + +LBB40_19: + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x0010850f; WORD $0x0000 // jne LBB40_21, $16(%rip) + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + WORD $0x294c; BYTE $0xc9 // subq %r9, %rcx + LONG $0xc0bc0f4c // bsfq %rax, %r8 + WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + +LBB40_21: + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xc121 // andl %eax, %ecx + WORD $0x1c8d; BYTE $0x09 // leal (%rcx,%rcx), %ebx + LONG $0x4e148d45 // leal (%r14,%rcx,2), %r10d + WORD $0xd3f7 // notl %ebx + WORD $0xc321 // andl %eax, %ebx + LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0xcb01 // addl %ecx, %ebx + LONG $0xc6920f41 // setb %r14b + WORD $0xdb01 // addl %ebx, %ebx + LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx + WORD $0x2144; BYTE $0xd3 // andl %r10d, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xdf21 // andl %ebx, %edi + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xff7f850f; WORD $0xffff // jne LBB40_16, $-129(%rip) + +LBB40_22: + LONG $0x20c68348 // addq $32, %rsi + LONG $0xe0c78349 // addq $-32, %r15 + +LBB40_23: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x00b0850f; WORD $0x0000 // jne LBB40_38, $176(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0083840f; WORD $0x0000 // je LBB40_35, $131(%rip) + +LBB40_25: + WORD $0x894d; BYTE $0xca // movq %r9, %r10 + WORD $0xf749; BYTE $0xda // negq %r10 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + +LBB40_26: + WORD $0xdb31 // xorl %ebx, %ebx + +LBB40_27: + LONG $0x1e3cb60f // movzbl (%rsi,%rbx), %edi + WORD $0xff83; BYTE $0x22 // cmpl $34, %edi + LONG $0x0061840f; WORD $0x0000 // je LBB40_34, $97(%rip) + WORD $0xff83; BYTE $0x5c // cmpl $92, %edi + LONG $0x0011840f; WORD $0x0000 // je LBB40_30, $17(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 + LONG $0xffde850f; WORD $0xffff // jne LBB40_27, $-34(%rip) + LONG $0x000058e9; BYTE $0x00 // jmp LBB40_36, $88(%rip) + +LBB40_30: + LONG $0xff4f8d49 // leaq $-1(%r15), %rcx + WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx + LONG $0xfece840f; WORD $0xffff // je LBB40_11, $-306(%rip) + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x000a850f; WORD $0x0000 // jne LBB40_33, $10(%rip) + LONG $0x32048d4d // leaq (%r10,%rsi), %r8 + WORD $0x0149; BYTE $0xd8 // addq %rbx, %r8 + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + +LBB40_33: + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + LONG $0x02c68348 // addq $2, %rsi + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx + LONG $0xfec18348 // addq $-2, %rcx + LONG $0xfec78349 // addq $-2, %r15 + WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + LONG $0xff95850f; WORD $0xffff // jne LBB40_26, $-107(%rip) + LONG $0xfffe94e9; BYTE $0xff // jmp LBB40_11, $-364(%rip) + +LBB40_34: + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + +LBB40_35: + WORD $0x294c; BYTE $0xce // subq %r9, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0xfffe83e9; BYTE $0xff // jmp LBB40_11, $-381(%rip) + +LBB40_36: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0x22ff8040 // cmpb $34, %dil + LONG $0xfe72850f; WORD $0xffff // jne LBB40_11, $-398(%rip) + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + LONG $0xffffdce9; BYTE $0xff // jmp LBB40_35, $-36(%rip) + +LBB40_38: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x002a840f; WORD $0x0000 // je LBB40_17, $42(%rip) + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x000c850f; WORD $0x0000 // jne LBB40_41, $12(%rip) + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + +LBB40_41: + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff49; BYTE $0xcf // decq %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xff2b850f; WORD $0xffff // jne LBB40_25, $-213(%rip) + LONG $0xffffa9e9; BYTE $0xff // jmp LBB40_35, $-87(%rip) + +LBB40_17: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffe2be9; BYTE $0xff // jmp LBB40_11, $-469(%rip) + BYTE $0x00 // .p2align 4, 0x00 + +LCPI41_0: + BYTE $0xf0 // .byte 240 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x80 // .byte 128 + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + BYTE $0x00 // .space 1, '\x00' + + // .p2align 4, 0x90 +_unescape: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x18ec8348 // subq $24, %rsp + WORD $0x8b4c; BYTE $0x2f // movq (%rdi), %r13 + WORD $0x294c; BYTE $0xee // subq %r13, %rsi + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x00d38e0f; WORD $0x0000 // jle LBB41_13, $211(%rip) + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0x01458d49 // leaq $1(%r13), %rax + LONG $0x4db60f41; BYTE $0x01 // movzbl $1(%r13), %ecx + LONG $0x53158d48; WORD $0x0077; BYTE $0x00 // leaq $30547(%rip), %rdx /* __UnquoteTab(%rip) */ + LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx + LONG $0x00fff981; WORD $0x0000 // cmpl $255, %ecx + LONG $0x0017840f; WORD $0x0000 // je LBB41_4, $23(%rip) + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0021850f; WORD $0x0000 // jne LBB41_6, $33(%rip) + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xfdc3c748; WORD $0xffff; BYTE $0xff // movq $-3, %rbx + LONG $0x000096e9; BYTE $0x00 // jmp LBB41_13, $150(%rip) + +LBB41_4: + LONG $0x03fe8348 // cmpq $3, %rsi + LONG $0x0019870f; WORD $0x0000 // ja LBB41_7, $25(%rip) + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0x000084e9; BYTE $0x00 // jmp LBB41_13, $132(%rip) + +LBB41_6: + WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) + LONG $0x02078349 // addq $2, (%r15) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0x000073e9; BYTE $0x00 // jmp LBB41_13, $115(%rip) + +LBB41_7: + LONG $0x024d8b41 // movl $2(%r13), %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xd0f7 // notl %eax + LONG $0xcfd0918d; WORD $0xcfcf // leal $-808464432(%rcx), %edx + LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax + WORD $0xd085 // testl %edx, %eax + LONG $0x004a850f; WORD $0x0000 // jne LBB41_11, $74(%rip) + LONG $0x1919918d; WORD $0x1919 // leal $421075225(%rcx), %edx + WORD $0xca09 // orl %ecx, %edx + LONG $0x8080c2f7; WORD $0x8080 // testl $-2139062144, %edx + LONG $0x0036850f; WORD $0x0000 // jne LBB41_11, $54(%rip) + WORD $0xca89 // movl %ecx, %edx + LONG $0x7f7fe281; WORD $0x7f7f // andl $2139062143, %edx + LONG $0xc0c0c0bf; BYTE $0xc0 // movl $-1061109568, %edi + WORD $0xd729 // subl %edx, %edi + LONG $0x46469a8d; WORD $0x4646 // leal $1179010630(%rdx), %ebx + WORD $0xc721 // andl %eax, %edi + WORD $0xdf85 // testl %ebx, %edi + LONG $0x0017850f; WORD $0x0000 // jne LBB41_11, $23(%rip) + LONG $0xe0e0e0bf; BYTE $0xe0 // movl $-522133280, %edi + WORD $0xd729 // subl %edx, %edi + LONG $0x3939c281; WORD $0x3939 // addl $960051513, %edx + WORD $0xf821 // andl %edi, %eax + WORD $0xd085 // testl %edx, %eax + LONG $0x0020840f; WORD $0x0000 // je LBB41_14, $32(%rip) + +LBB41_11: + LONG $0x02c58349 // addq $2, %r13 + WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) + +LBB41_12: + LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx + +LBB41_13: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0x18c48348 // addq $24, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB41_14: + WORD $0xc90f // bswapl %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx + WORD $0xc101 // addl %eax, %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xc809 // orl %ecx, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx + LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx + LONG $0xe0b60f44 // movzbl %al, %r12d + WORD $0x0941; BYTE $0xcc // orl %ecx, %r12d + LONG $0x06558d49 // leaq $6(%r13), %rdx + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + LONG $0x7ffc8341 // cmpl $127, %r12d + LONG $0x004c860f; WORD $0x0000 // jbe LBB41_18, $76(%rip) + LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d + LONG $0x004c860f; WORD $0x0000 // jbe LBB41_19, $76(%rip) + QUAD $0xffff200024bc8d41 // leal $-57344(%r12), %edi + LONG $0xf7ffff81; WORD $0xffff // cmpl $-2049, %edi + LONG $0x0055870f; WORD $0x0000 // ja LBB41_20, $85(%rip) + WORD $0xe9c1; BYTE $0x0c // shrl $12, %ecx + WORD $0xc980; BYTE $0xe0 // orb $-32, %cl + WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) + LONG $0x06ecc141 // shrl $6, %r12d + LONG $0x3fe48041 // andb $63, %r12b + LONG $0x80cc8041 // orb $-128, %r12b + LONG $0x01668845 // movb %r12b, $1(%r14) + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x02468841 // movb %al, $2(%r14) + LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx + LONG $0xffff5fe9; BYTE $0xff // jmp LBB41_13, $-161(%rip) + +LBB41_18: + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0xffff52e9; BYTE $0xff // jmp LBB41_13, $-174(%rip) + +LBB41_19: + LONG $0x06ecc141 // shrl $6, %r12d + LONG $0xc0cc8041 // orb $-64, %r12b + WORD $0x8845; BYTE $0x26 // movb %r12b, (%r14) + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x01468841 // movb %al, $1(%r14) + LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx + LONG $0xffff35e9; BYTE $0xff // jmp LBB41_13, $-203(%rip) + +LBB41_20: + LONG $0xfcc3c748; WORD $0xffff; BYTE $0xff // movq $-4, %rbx + LONG $0x06fe8348 // cmpq $6, %rsi + LONG $0xff24820f; WORD $0xffff // jb LBB41_13, $-220(%rip) + LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d + LONG $0xff17870f; WORD $0xffff // ja LBB41_13, $-233(%rip) + WORD $0x3a80; BYTE $0x5c // cmpb $92, (%rdx) + LONG $0xff0e850f; WORD $0xffff // jne LBB41_13, $-242(%rip) + LONG $0x077d8041; BYTE $0x75 // cmpb $117, $7(%r13) + LONG $0xff03850f; WORD $0xffff // jne LBB41_13, $-253(%rip) + LONG $0x08458d49 // leaq $8(%r13), %rax + LONG $0xc8458948 // movq %rax, $-56(%rbp) + LONG $0x087d8b41 // movl $8(%r13), %edi + WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) + LONG $0xff89b5e8; BYTE $0xff // callq _unhex16_is, $-30283(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x004f840f; WORD $0x0000 // je LBB41_27, $79(%rip) + WORD $0x4d8b; BYTE $0xd4 // movl $-44(%rbp), %ecx + WORD $0xc90f // bswapl %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx + WORD $0xc101 // addl %eax, %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xc809 // orl %ecx, %eax + WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx + WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax + LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax + WORD $0x148d; BYTE $0x08 // leal (%rax,%rcx), %edx + LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx + LONG $0xfbfffa81; WORD $0xffff // cmpl $-1025, %edx + LONG $0x0018870f; WORD $0x0000 // ja LBB41_28, $24(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xfffe98e9; BYTE $0xff // jmp LBB41_13, $-360(%rip) + +LBB41_27: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xfffe85e9; BYTE $0xff // jmp LBB41_12, $-379(%rip) + +LBB41_28: + WORD $0xc809 // orl %ecx, %eax + LONG $0x0ae4c141 // shll $10, %r12d + WORD $0xc189 // movl %eax, %ecx + WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx + WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax + LONG $0xa0240005; BYTE $0xfc // addl $-56613888, %eax + WORD $0xc289 // movl %eax, %edx + WORD $0xeac1; BYTE $0x12 // shrl $18, %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xeec1; BYTE $0x0c // shrl $12, %esi + LONG $0x3fe68040 // andb $63, %sil + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0x3f24 // andb $63, %al + WORD $0xe180; BYTE $0x3f // andb $63, %cl + LONG $0xc26ef9c5 // vmovd %edx, %xmm0 + LONG $0xd6b60f40 // movzbl %sil, %edx + LONG $0x2079e3c4; WORD $0x01c2 // vpinsrb $1, %edx, %xmm0, %xmm0 + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + LONG $0x2079e3c4; WORD $0x02c0 // vpinsrb $2, %eax, %xmm0, %xmm0 + WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax + LONG $0x2079e3c4; WORD $0x03c0 // vpinsrb $3, %eax, %xmm0, %xmm0 + QUAD $0xfffffd3105ebf9c5 // vpor $-719(%rip), %xmm0, %xmm0 /* LCPI41_0(%rip) */ + LONG $0x7e79c1c4; BYTE $0x06 // vmovd %xmm0, (%r14) + LONG $0x0cc58349 // addq $12, %r13 + WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) + LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx + LONG $0xfffe25e9; BYTE $0xff // jmp LBB41_13, $-475(%rip) + QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 + +_POW10_M128_TAB: + QUAD $0x1732c869cd60e453 // .quad 1671618768450675795 + QUAD $0xfa8fd5a0081c0288 // .quad -391859759250406776 + QUAD $0x0e7fbd42205c8eb4 // .quad 1044761730281672372 + QUAD $0x9c99e58405118195 // .quad -7162441377172586091 + QUAD $0x521fac92a873b261 // .quad 5917638181279478369 + QUAD $0xc3c05ee50655e1fa // .quad -4341365703038344710 + QUAD $0xe6a797b752909ef9 // .quad -1826324310255427847 + QUAD $0xf4b0769e47eb5a78 // .quad -815021110370542984 + QUAD $0x9028bed2939a635c // .quad -8058981721550724260 + QUAD $0x98ee4a22ecf3188b // .quad -7426917221622671221 + QUAD $0x7432ee873880fc33 // .quad 8373016921771146291 + QUAD $0xbf29dcaba82fdeae // .quad -4671960508600951122 + QUAD $0x113faa2906a13b3f // .quad 1242899115359157055 + QUAD $0xeef453d6923bd65a // .quad -1228264617323800998 + QUAD $0x4ac7ca59a424c507 // .quad 5388497965526861063 + QUAD $0x9558b4661b6565f8 // .quad -7685194413468457480 + QUAD $0x5d79bcf00d2df649 // .quad 6735622456908576329 + QUAD $0xbaaee17fa23ebf76 // .quad -4994806998408183946 + QUAD $0xf4d82c2c107973dc // .quad -803843965719055396 + QUAD $0xe95a99df8ace6f53 // .quad -1631822729582842029 + QUAD $0x79071b9b8a4be869 // .quad 8720969558280366185 + QUAD $0x91d8a02bb6c10594 // .quad -7937418233630358124 + QUAD $0x9748e2826cdee284 // .quad -7545532125859093884 + QUAD $0xb64ec836a47146f9 // .quad -5310086773610559751 + QUAD $0xfd1b1b2308169b25 // .quad -208543120469091547 + QUAD $0xe3e27a444d8d98b7 // .quad -2025922448585811785 + QUAD $0xfe30f0f5e50e20f7 // .quad -130339450293182217 + QUAD $0x8e6d8c6ab0787f72 // .quad -8183730558007214222 + QUAD $0xbdbd2d335e51a935 // .quad -4774610331293865675 + QUAD $0xb208ef855c969f4f // .quad -5617977179081629873 + QUAD $0xad2c788035e61382 // .quad -5968262914117332094 + QUAD $0xde8b2b66b3bc4723 // .quad -2410785455424649437 + QUAD $0x4c3bcb5021afcc31 // .quad 5493207715531443249 + QUAD $0x8b16fb203055ac76 // .quad -8424269937281487754 + QUAD $0xdf4abe242a1bbf3d // .quad -2356862392440471747 + QUAD $0xaddcb9e83c6b1793 // .quad -5918651403174471789 + QUAD $0xd71d6dad34a2af0d // .quad -2946077990550589683 + QUAD $0xd953e8624b85dd78 // .quad -2786628235540701832 + QUAD $0x8672648c40e5ad68 // .quad -8758827771735200408 + QUAD $0x87d4713d6f33aa6b // .quad -8659171674854020501 + QUAD $0x680efdaf511f18c2 // .quad 7498209359040551106 + QUAD $0xa9c98d8ccb009506 // .quad -6212278575140137722 + QUAD $0x0212bd1b2566def2 // .quad 149389661945913074 + QUAD $0xd43bf0effdc0ba48 // .quad -3153662200497784248 + QUAD $0x014bb630f7604b57 // .quad 93368538716195671 + QUAD $0x84a57695fe98746d // .quad -8888567902952197011 + QUAD $0x419ea3bd35385e2d // .quad 4728396691822632493 + QUAD $0xa5ced43b7e3e9188 // .quad -6499023860262858360 + QUAD $0x52064cac828675b9 // .quad 5910495864778290617 + QUAD $0xcf42894a5dce35ea // .quad -3512093806901185046 + QUAD $0x7343efebd1940993 // .quad 8305745933913819539 + QUAD $0x818995ce7aa0e1b2 // .quad -9112587656954322510 + QUAD $0x1014ebe6c5f90bf8 // .quad 1158810380537498616 + QUAD $0xa1ebfb4219491a1f // .quad -6779048552765515233 + QUAD $0xd41a26e077774ef6 // .quad -3163173042755514634 + QUAD $0xca66fa129f9b60a6 // .quad -3862124672529506138 + QUAD $0x8920b098955522b4 // .quad -8565652321871781196 + QUAD $0xfd00b897478238d0 // .quad -215969822234494768 + QUAD $0x55b46e5f5d5535b0 // .quad 6175682344898606512 + QUAD $0x9e20735e8cb16382 // .quad -7052510166537641086 + QUAD $0xeb2189f734aa831d // .quad -1503769105731517667 + QUAD $0xc5a890362fddbc62 // .quad -4203951689744663454 + QUAD $0xa5e9ec7501d523e4 // .quad -6491397400591784988 + QUAD $0xf712b443bbd52b7b // .quad -643253593753441413 + QUAD $0x47b233c92125366e // .quad 5166248661484910190 + QUAD $0x9a6bb0aa55653b2d // .quad -7319562523736982739 + QUAD $0x999ec0bb696e840a // .quad -7377247228426025974 + QUAD $0xc1069cd4eabe89f8 // .quad -4537767136243840520 + QUAD $0xc00670ea43ca250d // .quad -4609873017105144563 + QUAD $0xf148440a256e2c76 // .quad -1060522901877412746 + QUAD $0x380406926a5e5728 // .quad 4036358391950366504 + QUAD $0x96cd2a865764dbca // .quad -7580355841314464822 + QUAD $0xc605083704f5ecf2 // .quad -4177924046916817678 + QUAD $0xbc807527ed3e12bc // .quad -4863758783215693124 + QUAD $0xf7864a44c633682e // .quad -610719040218634194 + QUAD $0xeba09271e88d976b // .quad -1468012460592228501 + QUAD $0x7ab3ee6afbe0211d // .quad 8841672636718129437 + QUAD $0x93445b8731587ea3 // .quad -7835036815511224669 + QUAD $0x5960ea05bad82964 // .quad 6440404777470273892 + QUAD $0xb8157268fdae9e4c // .quad -5182110000961642932 + QUAD $0x6fb92487298e33bd // .quad 8050505971837842365 + QUAD $0xe61acf033d1a45df // .quad -1865951482774665761 + QUAD $0xa5d3b6d479f8e056 // .quad -6497648813669818282 + QUAD $0x8fd0c16206306bab // .quad -8083748704375247957 + QUAD $0x8f48a4899877186c // .quad -8122061017087272852 + QUAD $0xb3c4f1ba87bc8696 // .quad -5492999862041672042 + QUAD $0x331acdabfe94de87 // .quad 3682481783923072647 + QUAD $0xe0b62e2929aba83c // .quad -2254563809124702148 + QUAD $0x9ff0c08b7f1d0b14 // .quad -6921820921902855404 + QUAD $0x8c71dcd9ba0b4925 // .quad -8326631408344020699 + QUAD $0x07ecf0ae5ee44dd9 // .quad 571095884476206553 + QUAD $0xaf8e5410288e1b6f // .quad -5796603242002637969 + QUAD $0xc9e82cd9f69d6150 // .quad -3897816162832129712 + QUAD $0xdb71e91432b1a24a // .quad -2634068034075909558 + QUAD $0xbe311c083a225cd2 // .quad -4741978110983775022 + QUAD $0x892731ac9faf056e // .quad -8563821548938525330 + QUAD $0x6dbd630a48aaf406 // .quad 7907585416552444934 + QUAD $0xab70fe17c79ac6ca // .quad -6093090917745768758 + QUAD $0x092cbbccdad5b108 // .quad 661109733835780360 + QUAD $0xd64d3d9db981787d // .quad -3004677628754823043 + QUAD $0x25bbf56008c58ea5 // .quad 2719036592861056677 + QUAD $0x85f0468293f0eb4e // .quad -8795452545612846258 + QUAD $0xaf2af2b80af6f24e // .quad -5824576295778454962 + QUAD $0xa76c582338ed2621 // .quad -6382629663588669919 + QUAD $0x1af5af660db4aee1 // .quad 1942651667131707105 + QUAD $0xd1476e2c07286faa // .quad -3366601061058449494 + QUAD $0x50d98d9fc890ed4d // .quad 5825843310384704845 + QUAD $0x82cca4db847945ca // .quad -9021654690802612790 + QUAD $0xe50ff107bab528a0 // .quad -1941067898873894752 + QUAD $0xa37fce126597973c // .quad -6665382345075878084 + QUAD $0x1e53ed49a96272c8 // .quad 2185351144835019464 + QUAD $0xcc5fc196fefd7d0c // .quad -3720041912917459700 + QUAD $0x25e8e89c13bb0f7a // .quad 2731688931043774330 + QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721 + QUAD $0x77b191618c54e9ac // .quad 8624834609543440812 + QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807 + QUAD $0xd59df5b9ef6a2417 // .quad -3054014793352862697 + QUAD $0xc795830d75038c1d // .quad -4065198994811024355 + QUAD $0x4b0573286b44ad1d // .quad 5405853545163697437 + QUAD $0xf97ae3d0d2446f25 // .quad -469812725086392539 + QUAD $0x4ee367f9430aec32 // .quad 5684501474941004850 + QUAD $0x9becce62836ac577 // .quad -7211161980820077193 + QUAD $0x229c41f793cda73f // .quad 2493940825248868159 + QUAD $0xc2e801fb244576d5 // .quad -4402266457597708587 + QUAD $0x6b43527578c1110f // .quad 7729112049988473103 + QUAD $0xf3a20279ed56d48a // .quad -891147053569747830 + QUAD $0x830a13896b78aaa9 // .quad -9004363024039368023 + QUAD $0x9845418c345644d6 // .quad -7474495936122174250 + QUAD $0x23cc986bc656d553 // .quad 2579604275232953683 + QUAD $0xbe5691ef416bd60c // .quad -4731433901725329908 + QUAD $0x2cbfbe86b7ec8aa8 // .quad 3224505344041192104 + QUAD $0xedec366b11c6cb8f // .quad -1302606358729274481 + QUAD $0x7bf7d71432f3d6a9 // .quad 8932844867666826921 + QUAD $0x94b3a202eb1c3f39 // .quad -7731658001846878407 + QUAD $0xdaf5ccd93fb0cc53 // .quad -2669001970698630061 + QUAD $0xb9e08a83a5e34f07 // .quad -5052886483881210105 + QUAD $0xd1b3400f8f9cff68 // .quad -3336252463373287576 + QUAD $0xe858ad248f5c22c9 // .quad -1704422086424124727 + QUAD $0x23100809b9c21fa1 // .quad 2526528228819083169 + QUAD $0x91376c36d99995be // .quad -7982792831656159810 + QUAD $0xabd40a0c2832a78a // .quad -6065211750830921846 + QUAD $0xb58547448ffffb2d // .quad -5366805021142811859 + QUAD $0x16c90c8f323f516c // .quad 1641857348316123500 + QUAD $0xe2e69915b3fff9f9 // .quad -2096820258001126919 + QUAD $0xae3da7d97f6792e3 // .quad -5891368184943504669 + QUAD $0x8dd01fad907ffc3b // .quad -8228041688891786181 + QUAD $0x99cd11cfdf41779c // .quad -7364210231179380836 + QUAD $0xb1442798f49ffb4a // .quad -5673366092687344822 + QUAD $0x40405643d711d583 // .quad 4629795266307937667 + QUAD $0xdd95317f31c7fa1d // .quad -2480021597431793123 + QUAD $0x482835ea666b2572 // .quad 5199465050656154994 + QUAD $0x8a7d3eef7f1cfc52 // .quad -8467542526035952558 + QUAD $0xda3243650005eecf // .quad -2724040723534582065 + QUAD $0xad1c8eab5ee43b66 // .quad -5972742139117552794 + QUAD $0x90bed43e40076a82 // .quad -8016736922845615486 + QUAD $0xd863b256369d4a40 // .quad -2854241655469553088 + QUAD $0x5a7744a6e804a291 // .quad 6518754469289960081 + QUAD $0x873e4f75e2224e68 // .quad -8701430062309552536 + QUAD $0x711515d0a205cb36 // .quad 8148443086612450102 + QUAD $0xa90de3535aaae202 // .quad -6265101559459552766 + QUAD $0x0d5a5b44ca873e03 // .quad 962181821410786819 + QUAD $0xd3515c2831559a83 // .quad -3219690930897053053 + QUAD $0xe858790afe9486c2 // .quad -1704479370831952190 + QUAD $0x8412d9991ed58091 // .quad -8929835859451740015 + QUAD $0x626e974dbe39a872 // .quad 7092772823314835570 + QUAD $0xa5178fff668ae0b6 // .quad -6550608805887287114 + QUAD $0xfb0a3d212dc8128f // .quad -357406007711231345 + QUAD $0xce5d73ff402d98e3 // .quad -3576574988931720989 + QUAD $0x7ce66634bc9d0b99 // .quad 8999993282035256217 + QUAD $0x80fa687f881c7f8e // .quad -9152888395723407474 + QUAD $0x1c1fffc1ebc44e80 // .quad 2026619565689294464 + QUAD $0xa139029f6a239f72 // .quad -6829424476226871438 + QUAD $0xa327ffb266b56220 // .quad -6690097579743157728 + QUAD $0xc987434744ac874e // .quad -3925094576856201394 + QUAD $0x4bf1ff9f0062baa8 // .quad 5472436080603216552 + QUAD $0xfbe9141915d7a922 // .quad -294682202642863838 + QUAD $0x6f773fc3603db4a9 // .quad 8031958568804398249 + QUAD $0x9d71ac8fada6c9b5 // .quad -7101705404292871755 + QUAD $0xcb550fb4384d21d3 // .quad -3795109844276665901 + QUAD $0xc4ce17b399107c22 // .quad -4265445736938701790 + QUAD $0x7e2a53a146606a48 // .quad 9091170749936331336 + QUAD $0xf6019da07f549b2b // .quad -720121152745989333 + QUAD $0x2eda7444cbfc426d // .quad 3376138709496513133 + QUAD $0x99c102844f94e0fb // .quad -7367604748107325189 + QUAD $0xfa911155fefb5308 // .quad -391512631556746488 + QUAD $0xc0314325637a1939 // .quad -4597819916706768583 + QUAD $0x793555ab7eba27ca // .quad 8733981247408842698 + QUAD $0xf03d93eebc589f88 // .quad -1135588877456072824 + QUAD $0x4bc1558b2f3458de // .quad 5458738279630526686 + QUAD $0x96267c7535b763b5 // .quad -7627272076051127371 + QUAD $0x9eb1aaedfb016f16 // .quad -7011635205744005354 + QUAD $0xbbb01b9283253ca2 // .quad -4922404076636521310 + QUAD $0x465e15a979c1cadc // .quad 5070514048102157020 + QUAD $0xea9c227723ee8bcb // .quad -1541319077368263733 + QUAD $0x0bfacd89ec191ec9 // .quad 863228270850154185 + QUAD $0x92a1958a7675175f // .quad -7880853450996246689 + QUAD $0xcef980ec671f667b // .quad -3532650679864695173 + QUAD $0xb749faed14125d36 // .quad -5239380795317920458 + QUAD $0x82b7e12780e7401a // .quad -9027499368258256870 + QUAD $0xe51c79a85916f484 // .quad -1937539975720012668 + QUAD $0xd1b2ecb8b0908810 // .quad -3336344095947716592 + QUAD $0x8f31cc0937ae58d2 // .quad -8128491512466089774 + QUAD $0x861fa7e6dcb4aa15 // .quad -8782116138362033643 + QUAD $0xb2fe3f0b8599ef07 // .quad -5548928372155224313 + QUAD $0x67a791e093e1d49a // .quad 7469098900757009562 + QUAD $0xdfbdcece67006ac9 // .quad -2324474446766642487 + QUAD $0xe0c8bb2c5c6d24e0 // .quad -2249342214667950880 + QUAD $0x8bd6a141006042bd // .quad -8370325556870233411 + QUAD $0x58fae9f773886e18 // .quad 6411694268519837208 + QUAD $0xaecc49914078536d // .quad -5851220927660403859 + QUAD $0xaf39a475506a899e // .quad -5820440219632367202 + QUAD $0xda7f5bf590966848 // .quad -2702340141148116920 + QUAD $0x6d8406c952429603 // .quad 7891439908798240259 + QUAD $0x888f99797a5e012d // .quad -8606491615858654931 + QUAD $0xc8e5087ba6d33b83 // .quad -3970758169284363389 + QUAD $0xaab37fd7d8f58178 // .quad -6146428501395930760 + QUAD $0xfb1e4a9a90880a64 // .quad -351761693178066332 + QUAD $0xd5605fcdcf32e1d6 // .quad -3071349608317525546 + QUAD $0x5cf2eea09a55067f // .quad 6697677969404790399 + QUAD $0x855c3be0a17fcd26 // .quad -8837122532839535322 + QUAD $0xf42faa48c0ea481e // .quad -851274575098787810 + QUAD $0xa6b34ad8c9dfc06f // .quad -6434717147622031249 + QUAD $0xf13b94daf124da26 // .quad -1064093218873484762 + QUAD $0xd0601d8efc57b08b // .quad -3431710416100151157 + QUAD $0x76c53d08d6b70858 // .quad 8558313775058847832 + QUAD $0x823c12795db6ce57 // .quad -9062348037703676329 + QUAD $0x54768c4b0c64ca6e // .quad 6086206200396171886 + QUAD $0xa2cb1717b52481ed // .quad -6716249028702207507 + QUAD $0xa9942f5dcf7dfd09 // .quad -6227300304786948855 + QUAD $0xcb7ddcdda26da268 // .quad -3783625267450371480 + QUAD $0xd3f93b35435d7c4c // .quad -3172439362556298164 + QUAD $0xfe5d54150b090b02 // .quad -117845565885576446 + QUAD $0xc47bc5014a1a6daf // .quad -4288617610811380305 + QUAD $0x9efa548d26e5a6e1 // .quad -6991182506319567135 + QUAD $0x359ab6419ca1091b // .quad 3862600023340550427 + QUAD $0xc6b8e9b0709f109a // .quad -4127292114472071014 + QUAD $0xc30163d203c94b62 // .quad -4395122007679087774 + QUAD $0xf867241c8cc6d4c0 // .quad -547429124662700864 + QUAD $0x79e0de63425dcf1d // .quad 8782263791269039901 + QUAD $0x9b407691d7fc44f8 // .quad -7259672230555269896 + QUAD $0x985915fc12f542e4 // .quad -7468914334623251740 + QUAD $0xc21094364dfb5636 // .quad -4462904269766699466 + QUAD $0x3e6f5b7b17b2939d // .quad 4498915137003099037 + QUAD $0xf294b943e17a2bc4 // .quad -966944318780986428 + QUAD $0xa705992ceecf9c42 // .quad -6411550076227838910 + QUAD $0x979cf3ca6cec5b5a // .quad -7521869226879198374 + QUAD $0x50c6ff782a838353 // .quad 5820620459997365075 + QUAD $0xbd8430bd08277231 // .quad -4790650515171610063 + QUAD $0xa4f8bf5635246428 // .quad -6559282480285457368 + QUAD $0xece53cec4a314ebd // .quad -1376627125537124675 + QUAD $0x871b7795e136be99 // .quad -8711237568605798759 + QUAD $0x940f4613ae5ed136 // .quad -7777920981101784778 + QUAD $0x28e2557b59846e3f // .quad 2946011094524915263 + QUAD $0xb913179899f68584 // .quad -5110715207949843068 + QUAD $0x331aeada2fe589cf // .quad 3682513868156144079 + QUAD $0xe757dd7ec07426e5 // .quad -1776707991509915931 + QUAD $0x3ff0d2c85def7621 // .quad 4607414176811284001 + QUAD $0x9096ea6f3848984f // .quad -8027971522334779313 + QUAD $0x0fed077a756b53a9 // .quad 1147581702586717097 + QUAD $0xb4bca50b065abe63 // .quad -5423278384491086237 + QUAD $0xd3e8495912c62894 // .quad -3177208890193991532 + QUAD $0xe1ebce4dc7f16dfb // .quad -2167411962186469893 + QUAD $0x64712dd7abbbd95c // .quad 7237616480483531100 + QUAD $0x8d3360f09cf6e4bd // .quad -8272161504007625539 + QUAD $0xbd8d794d96aacfb3 // .quad -4788037454677749837 + QUAD $0xb080392cc4349dec // .quad -5728515861582144020 + QUAD $0xecf0d7a0fc5583a0 // .quad -1373360799919799392 + QUAD $0xdca04777f541c567 // .quad -2548958808550292121 + QUAD $0xf41686c49db57244 // .quad -858350499949874620 + QUAD $0x89e42caaf9491b60 // .quad -8510628282985014432 + QUAD $0x311c2875c522ced5 // .quad 3538747893490044629 + QUAD $0xac5d37d5b79b6239 // .quad -6026599335303880135 + QUAD $0x7d633293366b828b // .quad 9035120885289943691 + QUAD $0xd77485cb25823ac7 // .quad -2921563150702462265 + QUAD $0xae5dff9c02033197 // .quad -5882264492762254953 + QUAD $0x86a8d39ef77164bc // .quad -8743505996830120772 + QUAD $0xd9f57f830283fdfc // .quad -2741144597525430788 + QUAD $0xa8530886b54dbdeb // .quad -6317696477610263061 + QUAD $0xd072df63c324fd7b // .quad -3426430746906788485 + QUAD $0xd267caa862a12d66 // .quad -3285434578585440922 + QUAD $0x4247cb9e59f71e6d // .quad 4776009810824339053 + QUAD $0x8380dea93da4bc60 // .quad -8970925639256982432 + QUAD $0x52d9be85f074e608 // .quad 5970012263530423816 + QUAD $0xa46116538d0deb78 // .quad -6601971030643840136 + QUAD $0x67902e276c921f8b // .quad 7462515329413029771 + QUAD $0xcd795be870516656 // .quad -3640777769877412266 + QUAD $0x00ba1cd8a3db53b6 // .quad 52386062455755702 + QUAD $0x806bd9714632dff6 // .quad -9193015133814464522 + QUAD $0x80e8a40eccd228a4 // .quad -9157889458785081180 + QUAD $0xa086cfcd97bf97f3 // .quad -6879582898840692749 + QUAD $0x6122cd128006b2cd // .quad 6999382250228200141 + QUAD $0xc8a883c0fdaf7df0 // .quad -3987792605123478032 + QUAD $0x796b805720085f81 // .quad 8749227812785250177 + QUAD $0xfad2a4b13d1b5d6c // .quad -373054737976959636 + QUAD $0xcbe3303674053bb0 // .quad -3755104653863994448 + QUAD $0x9cc3a6eec6311a63 // .quad -7150688238876681629 + QUAD $0xbedbfc4411068a9c // .quad -4693880817329993060 + QUAD $0xc3f490aa77bd60fc // .quad -4326674280168464132 + QUAD $0xee92fb5515482d44 // .quad -1255665003235103420 + QUAD $0xf4f1b4d515acb93b // .quad -796656831783192261 + QUAD $0x751bdd152d4d1c4a // .quad 8438581409832836170 + QUAD $0x991711052d8bf3c5 // .quad -7415439547505577019 + QUAD $0xd262d45a78a0635d // .quad -3286831292991118499 + QUAD $0xbf5cd54678eef0b6 // .quad -4657613415954583370 + QUAD $0x86fb897116c87c34 // .quad -8720225134666286028 + QUAD $0xef340a98172aace4 // .quad -1210330751515841308 + QUAD $0xd45d35e6ae3d4da0 // .quad -3144297699952734816 + QUAD $0x9580869f0e7aac0e // .quad -7673985747338482674 + QUAD $0x8974836059cca109 // .quad -8542058143368306423 + QUAD $0xbae0a846d2195712 // .quad -4980796165745715438 + QUAD $0x2bd1a438703fc94b // .quad 3157485376071780683 + QUAD $0xe998d258869facd7 // .quad -1614309188754756393 + QUAD $0x7b6306a34627ddcf // .quad 8890957387685944783 + QUAD $0x91ff83775423cc06 // .quad -7926472270612804602 + QUAD $0x1a3bc84c17b1d542 // .quad 1890324697752655170 + QUAD $0xb67f6455292cbf08 // .quad -5296404319838617848 + QUAD $0x20caba5f1d9e4a93 // .quad 2362905872190818963 + QUAD $0xe41f3d6a7377eeca // .quad -2008819381370884406 + QUAD $0x547eb47b7282ee9c // .quad 6088502188546649756 + QUAD $0x8e938662882af53e // .quad -8173041140997884610 + QUAD $0xe99e619a4f23aa43 // .quad -1612744301171463613 + QUAD $0xb23867fb2a35b28d // .quad -5604615407819967859 + QUAD $0x6405fa00e2ec94d4 // .quad 7207441660390446292 + QUAD $0xdec681f9f4c31f31 // .quad -2394083241347571919 + QUAD $0xde83bc408dd3dd04 // .quad -2412877989897052924 + QUAD $0x8b3c113c38f9f37e // .quad -8413831053483314306 + QUAD $0x9624ab50b148d445 // .quad -7627783505798704059 + QUAD $0xae0b158b4738705e // .quad -5905602798426754978 + QUAD $0x3badd624dd9b0957 // .quad 4300328673033783639 + QUAD $0xd98ddaee19068c76 // .quad -2770317479606055818 + QUAD $0xe54ca5d70a80e5d6 // .quad -1923980597781273130 + QUAD $0x87f8a8d4cfa417c9 // .quad -8648977452394866743 + QUAD $0x5e9fcf4ccd211f4c // .quad 6818396289628184396 + QUAD $0xa9f6d30a038d1dbc // .quad -6199535797066195524 + QUAD $0x7647c3200069671f // .quad 8522995362035230495 + QUAD $0xd47487cc8470652b // .quad -3137733727905356501 + QUAD $0x29ecd9f40041e073 // .quad 3021029092058325107 + QUAD $0x84c8d4dfd2c63f3b // .quad -8878612607581929669 + QUAD $0xf468107100525890 // .quad -835399653354481520 + QUAD $0xa5fb0a17c777cf09 // .quad -6486579741050024183 + QUAD $0x7182148d4066eeb4 // .quad 8179122470161673908 + QUAD $0xcf79cc9db955c2cc // .quad -3496538657885142324 + QUAD $0xc6f14cd848405530 // .quad -4111420493003729616 + QUAD $0x81ac1fe293d599bf // .quad -9102865688819295809 + QUAD $0xb8ada00e5a506a7c // .quad -5139275616254662020 + QUAD $0xa21727db38cb002f // .quad -6766896092596731857 + QUAD $0xa6d90811f0e4851c // .quad -6424094520318327524 + QUAD $0xca9cf1d206fdc03b // .quad -3846934097318526917 + QUAD $0x908f4a166d1da663 // .quad -8030118150397909405 + QUAD $0xfd442e4688bd304a // .quad -196981603220770742 + QUAD $0x9a598e4e043287fe // .quad -7324666853212387330 + QUAD $0x9e4a9cec15763e2e // .quad -7040642529654063570 + QUAD $0x40eff1e1853f29fd // .quad 4679224488766679549 + QUAD $0xc5dd44271ad3cdba // .quad -4189117143640191558 + QUAD $0xd12bee59e68ef47c // .quad -3374341425896426372 + QUAD $0xf7549530e188c128 // .quad -624710411122851544 + QUAD $0x82bb74f8301958ce // .quad -9026492418826348338 + QUAD $0x9a94dd3e8cf578b9 // .quad -7307973034592864071 + QUAD $0xe36a52363c1faf01 // .quad -2059743486678159615 + QUAD $0xc13a148e3032d6e7 // .quad -4523280274813692185 + QUAD $0xdc44e6c3cb279ac1 // .quad -2574679358347699519 + QUAD $0xf18899b1bc3f8ca1 // .quad -1042414325089727327 + QUAD $0x29ab103a5ef8c0b9 // .quad 3002511419460075705 + QUAD $0x96f5600f15a7b7e5 // .quad -7569037980822161435 + QUAD $0x7415d448f6b6f0e7 // .quad 8364825292752482535 + QUAD $0xbcb2b812db11a5de // .quad -4849611457600313890 + QUAD $0x111b495b3464ad21 // .quad 1232659579085827361 + QUAD $0xebdf661791d60f56 // .quad -1450328303573004458 + QUAD $0xcab10dd900beec34 // .quad -3841273781498745804 + QUAD $0x936b9fcebb25c995 // .quad -7823984217374209643 + QUAD $0x3d5d514f40eea742 // .quad 4421779809981343554 + QUAD $0xb84687c269ef3bfb // .quad -5168294253290374149 + QUAD $0x0cb4a5a3112a5112 // .quad 915538744049291538 + QUAD $0xe65829b3046b0afa // .quad -1848681798185579782 + QUAD $0x47f0e785eaba72ab // .quad 5183897733458195115 + QUAD $0x8ff71a0fe2c2e6dc // .quad -8072955151507069220 + QUAD $0x59ed216765690f56 // .quad 6479872166822743894 + QUAD $0xb3f4e093db73a093 // .quad -5479507920956448621 + QUAD $0x306869c13ec3532c // .quad 3488154190101041964 + QUAD $0xe0f218b8d25088b8 // .quad -2237698882768172872 + QUAD $0x1e414218c73a13fb // .quad 2180096368813151227 + QUAD $0x8c974f7383725573 // .quad -8316090829371189901 + QUAD $0xe5d1929ef90898fa // .quad -1886565557410948870 + QUAD $0xafbd2350644eeacf // .quad -5783427518286599473 + QUAD $0xdf45f746b74abf39 // .quad -2358206946763686087 + QUAD $0xdbac6c247d62a583 // .quad -2617598379430861437 + QUAD $0x6b8bba8c328eb783 // .quad 7749492695127472003 + QUAD $0x894bc396ce5da772 // .quad -8553528014785370254 + QUAD $0x066ea92f3f326564 // .quad 463493832054564196 + QUAD $0xab9eb47c81f5114f // .quad -6080224000054324913 + QUAD $0xc80a537b0efefebd // .quad -4032318728359182659 + QUAD $0xd686619ba27255a2 // .quad -2988593981640518238 + QUAD $0xbd06742ce95f5f36 // .quad -4826042214438183114 + QUAD $0x8613fd0145877585 // .quad -8785400266166405755 + QUAD $0x2c48113823b73704 // .quad 3190819268807046916 + QUAD $0xa798fc4196e952e7 // .quad -6370064314280619289 + QUAD $0xf75a15862ca504c5 // .quad -623161932418579259 + QUAD $0xd17f3b51fca3a7a0 // .quad -3350894374423386208 + QUAD $0x9a984d73dbe722fb // .quad -7307005235402693893 + QUAD $0x82ef85133de648c4 // .quad -9011838011655698236 + QUAD $0xc13e60d0d2e0ebba // .quad -4522070525825979462 + QUAD $0xa3ab66580d5fdaf5 // .quad -6653111496142234891 + QUAD $0x318df905079926a8 // .quad 3570783879572301480 + QUAD $0xcc963fee10b7d1b3 // .quad -3704703351750405709 + QUAD $0xfdf17746497f7052 // .quad -148206168962011054 + QUAD $0xffbbcfe994e5c61f // .quad -19193171260619233 + QUAD $0xfeb6ea8bedefa633 // .quad -92628855601256909 + QUAD $0x9fd561f1fd0f9bd3 // .quad -6929524759678968877 + QUAD $0xfe64a52ee96b8fc0 // .quad -115786069501571136 + QUAD $0xc7caba6e7c5382c8 // .quad -4050219931171323192 + QUAD $0x3dfdce7aa3c673b0 // .quad 4466953431550423984 + QUAD $0xf9bd690a1b68637b // .quad -451088895536766085 + QUAD $0x06bea10ca65c084e // .quad 486002885505321038 + QUAD $0x9c1661a651213e2d // .quad -7199459587351560659 + QUAD $0x486e494fcff30a62 // .quad 5219189625309039202 + QUAD $0xc31bfa0fe5698db8 // .quad -4387638465762062920 + QUAD $0x5a89dba3c3efccfa // .quad 6523987031636299002 + QUAD $0xf3e2f893dec3f126 // .quad -872862063775190746 + QUAD $0xf89629465a75e01c // .quad -534194123654701028 + QUAD $0x986ddb5c6b3a76b7 // .quad -7463067817500576073 + QUAD $0xf6bbb397f1135823 // .quad -667742654568376285 + QUAD $0xbe89523386091465 // .quad -4717148753448332187 + QUAD $0x746aa07ded582e2c // .quad 8388693718644305452 + QUAD $0xee2ba6c0678b597f // .quad -1284749923383027329 + QUAD $0xa8c2a44eb4571cdc // .quad -6286281471915778852 + QUAD $0x94db483840b717ef // .quad -7720497729755473937 + QUAD $0x92f34d62616ce413 // .quad -7857851839894723565 + QUAD $0xba121a4650e4ddeb // .quad -5038936143766954517 + QUAD $0x77b020baf9c81d17 // .quad 8624429273841147159 + QUAD $0xe896a0d7e51e1566 // .quad -1686984161281305242 + QUAD $0x0ace1474dc1d122e // .quad 778582277723329070 + QUAD $0x915e2486ef32cd60 // .quad -7971894128441897632 + QUAD $0x0d819992132456ba // .quad 973227847154161338 + QUAD $0xb5b5ada8aaff80b8 // .quad -5353181642124984136 + QUAD $0x10e1fff697ed6c69 // .quad 1216534808942701673 + QUAD $0xe3231912d5bf60e6 // .quad -2079791034228842266 + QUAD $0xca8d3ffa1ef463c1 // .quad -3851351762838199359 + QUAD $0x8df5efabc5979c8f // .quad -8217398424034108273 + QUAD $0xbd308ff8a6b17cb2 // .quad -4814189703547749198 + QUAD $0xb1736b96b6fd83b3 // .quad -5660062011615247437 + QUAD $0xac7cb3f6d05ddbde // .quad -6017737129434686498 + QUAD $0xddd0467c64bce4a0 // .quad -2463391496091671392 + QUAD $0x6bcdf07a423aa96b // .quad 7768129340171790699 + QUAD $0x8aa22c0dbef60ee4 // .quad -8457148712698376476 + QUAD $0x86c16c98d2c953c6 // .quad -8736582398494813242 + QUAD $0xad4ab7112eb3929d // .quad -5959749872445582691 + QUAD $0xe871c7bf077ba8b7 // .quad -1697355961263740745 + QUAD $0xd89d64d57a607744 // .quad -2838001322129590460 + QUAD $0x11471cd764ad4972 // .quad 1244995533423855986 + QUAD $0x87625f056c7c4a8b // .quad -8691279853972075893 + QUAD $0xd598e40d3dd89bcf // .quad -3055441601647567921 + QUAD $0xa93af6c6c79b5d2d // .quad -6252413799037706963 + QUAD $0x4aff1d108d4ec2c3 // .quad 5404070034795315907 + QUAD $0xd389b47879823479 // .quad -3203831230369745799 + QUAD $0xcedf722a585139ba // .quad -3539985255894009414 + QUAD $0x843610cb4bf160cb // .quad -8919923546622172981 + QUAD $0xc2974eb4ee658828 // .quad -4424981569867511768 + QUAD $0xa54394fe1eedb8fe // .quad -6538218414850328322 + QUAD $0x733d226229feea32 // .quad 8303831092947774002 + QUAD $0xce947a3da6a9273e // .quad -3561087000135522498 + QUAD $0x0806357d5a3f525f // .quad 578208414664970847 + QUAD $0x811ccc668829b887 // .quad -9143208402725783417 + QUAD $0xca07c2dcb0cf26f7 // .quad -3888925500096174345 + QUAD $0xa163ff802a3426a8 // .quad -6817324484979841368 + QUAD $0xfc89b393dd02f0b5 // .quad -249470856692830027 + QUAD $0xc9bcff6034c13052 // .quad -3909969587797413806 + QUAD $0xbbac2078d443ace2 // .quad -4923524589293425438 + QUAD $0xfc2c3f3841f17c67 // .quad -275775966319379353 + QUAD $0xd54b944b84aa4c0d // .quad -3077202868308390899 + QUAD $0x9d9ba7832936edc0 // .quad -7089889006590693952 + QUAD $0x0a9e795e65d4df11 // .quad 765182433041899281 + QUAD $0xc5029163f384a931 // .quad -4250675239810979535 + QUAD $0x4d4617b5ff4a16d5 // .quad 5568164059729762005 + QUAD $0xf64335bcf065d37d // .quad -701658031336336515 + QUAD $0x504bced1bf8e4e45 // .quad 5785945546544795205 + QUAD $0x99ea0196163fa42e // .quad -7356065297226292178 + QUAD $0xe45ec2862f71e1d6 // .quad -1990940103673781802 + QUAD $0xc06481fb9bcf8d39 // .quad -4583395603105477319 + QUAD $0x5d767327bb4e5a4c // .quad 6734696907262548556 + QUAD $0xf07da27a82c37088 // .quad -1117558485454458744 + QUAD $0x3a6a07f8d510f86f // .quad 4209185567039092847 + QUAD $0x964e858c91ba2655 // .quad -7616003081050118571 + QUAD $0x890489f70a55368b // .quad -8573576096483297653 + QUAD $0xbbe226efb628afea // .quad -4908317832885260310 + QUAD $0x2b45ac74ccea842e // .quad 3118087934678041646 + QUAD $0xeadab0aba3b2dbe5 // .quad -1523711272679187483 + QUAD $0x3b0b8bc90012929d // .quad 4254647968387469981 + QUAD $0x92c8ae6b464fc96f // .quad -7869848573065574033 + QUAD $0x09ce6ebb40173744 // .quad 706623942056949572 + QUAD $0xb77ada0617e3bbcb // .quad -5225624697904579637 + QUAD $0xcc420a6a101d0515 // .quad -3728406090856200939 + QUAD $0xe55990879ddcaabd // .quad -1920344853953336643 + QUAD $0x9fa946824a12232d // .quad -6941939825212513491 + QUAD $0x8f57fa54c2a9eab6 // .quad -8117744561361917258 + QUAD $0x47939822dc96abf9 // .quad 5157633273766521849 + QUAD $0xb32df8e9f3546564 // .quad -5535494683275008668 + QUAD $0x59787e2b93bc56f7 // .quad 6447041592208152311 + QUAD $0xdff9772470297ebd // .quad -2307682335666372931 + QUAD $0x57eb4edb3c55b65a // .quad 6335244004343789146 + QUAD $0x8bfbea76c619ef36 // .quad -8359830487432564938 + QUAD $0xede622920b6b23f1 // .quad -1304317031425039375 + QUAD $0xaefae51477a06b03 // .quad -5838102090863318269 + QUAD $0xe95fab368e45eced // .quad -1630396289281299219 + QUAD $0xdab99e59958885c4 // .quad -2685941595151759932 + QUAD $0x11dbcb0218ebb414 // .quad 1286845328412881940 + QUAD $0x88b402f7fd75539b // .quad -8596242524610931813 + QUAD $0xd652bdc29f26a119 // .quad -3003129357911285479 + QUAD $0xaae103b5fcd2a881 // .quad -6133617137336276863 + QUAD $0x4be76d3346f0495f // .quad 5469460339465668959 + QUAD $0xd59944a37c0752a2 // .quad -3055335403242958174 + QUAD $0x6f70a4400c562ddb // .quad 8030098730593431003 + QUAD $0x857fcae62d8493a5 // .quad -8827113654667930715 + QUAD $0xcb4ccd500f6bb952 // .quad -3797434642040374958 + QUAD $0xa6dfbd9fb8e5b88e // .quad -6422206049907525490 + QUAD $0x7e2000a41346a7a7 // .quad 9088264752731695015 + QUAD $0xd097ad07a71f26b2 // .quad -3416071543957018958 + QUAD $0x8ed400668c0c28c8 // .quad -8154892584824854328 + QUAD $0x825ecc24c873782f // .quad -9052573742614218705 + QUAD $0x728900802f0f32fa // .quad 8253128342678483706 + QUAD $0xa2f67f2dfa90563b // .quad -6704031159840385477 + QUAD $0x4f2b40a03ad2ffb9 // .quad 5704724409920716729 + QUAD $0xcbb41ef979346bca // .quad -3768352931373093942 + QUAD $0xe2f610c84987bfa8 // .quad -2092466524453879896 + QUAD $0xfea126b7d78186bc // .quad -98755145788979524 + QUAD $0x0dd9ca7d2df4d7c9 // .quad 998051431430019017 + QUAD $0x9f24b832e6b0f436 // .quad -6979250993759194058 + QUAD $0x91503d1c79720dbb // .quad -7975807747567252037 + QUAD $0xc6ede63fa05d3143 // .quad -4112377723771604669 + QUAD $0x75a44c6397ce912a // .quad 8476984389250486570 + QUAD $0xf8a95fcf88747d94 // .quad -528786136287117932 + QUAD $0xc986afbe3ee11aba // .quad -3925256793573221702 + QUAD $0x9b69dbe1b548ce7c // .quad -7248020362820530564 + QUAD $0xfbe85badce996168 // .quad -294884973539139224 + QUAD $0xc24452da229b021b // .quad -4448339435098275301 + QUAD $0xfae27299423fb9c3 // .quad -368606216923924029 + QUAD $0xf2d56790ab41c2a2 // .quad -948738275445456222 + QUAD $0xdccd879fc967d41a // .quad -2536221894791146470 + QUAD $0x97c560ba6b0919a5 // .quad -7510490449794491995 + QUAD $0x5400e987bbc1c920 // .quad 6053094668365842720 + QUAD $0xbdb6b8e905cb600f // .quad -4776427043815727089 + QUAD $0x290123e9aab23b68 // .quad 2954682317029915496 + QUAD $0xed246723473e3813 // .quad -1358847786342270957 + QUAD $0xf9a0b6720aaf6521 // .quad -459166561069996767 + QUAD $0x9436c0760c86e30b // .quad -7766808894105001205 + QUAD $0xf808e40e8d5b3e69 // .quad -573958201337495959 + QUAD $0xb94470938fa89bce // .quad -5096825099203863602 + QUAD $0xb60b1d1230b20e04 // .quad -5329133770099257852 + QUAD $0xe7958cb87392c2c2 // .quad -1759345355577441598 + QUAD $0xb1c6f22b5e6f48c2 // .quad -5636551615525730110 + QUAD $0x90bd77f3483bb9b9 // .quad -8017119874876982855 + QUAD $0x1e38aeb6360b1af3 // .quad 2177682517447613171 + QUAD $0xb4ecd5f01a4aa828 // .quad -5409713825168840664 + QUAD $0x25c6da63c38de1b0 // .quad 2722103146809516464 + QUAD $0xe2280b6c20dd5232 // .quad -2150456263033662926 + QUAD $0x579c487e5a38ad0e // .quad 6313000485183335694 + QUAD $0x8d590723948a535f // .quad -8261564192037121185 + QUAD $0x2d835a9df0c6d851 // .quad 3279564588051781713 + QUAD $0xb0af48ec79ace837 // .quad -5715269221619013577 + QUAD $0xf8e431456cf88e65 // .quad -512230283362660763 + QUAD $0xdcdb1b2798182244 // .quad -2532400508596379068 + QUAD $0x1b8e9ecb641b58ff // .quad 1985699082112030975 + QUAD $0x8a08f0f8bf0f156b // .quad -8500279345513818773 + QUAD $0xe272467e3d222f3f // .quad -2129562165787349185 + QUAD $0xac8b2d36eed2dac5 // .quad -6013663163464885563 + QUAD $0x5b0ed81dcc6abb0f // .quad 6561419329620589327 + QUAD $0xd7adf884aa879177 // .quad -2905392935903719049 + QUAD $0x98e947129fc2b4e9 // .quad -7428327965055601431 + QUAD $0x86ccbb52ea94baea // .quad -8733399612580906262 + QUAD $0x3f2398d747b36224 // .quad 4549648098962661924 + QUAD $0xa87fea27a539e9a5 // .quad -6305063497298744923 + QUAD $0x8eec7f0d19a03aad // .quad -8147997931578836307 + QUAD $0xd29fe4b18e88640e // .quad -3269643353196043250 + QUAD $0x1953cf68300424ac // .quad 1825030320404309164 + QUAD $0x83a3eeeef9153e89 // .quad -8961056123388608887 + QUAD $0x5fa8c3423c052dd7 // .quad 6892973918932774359 + QUAD $0xa48ceaaab75a8e2b // .quad -6589634135808373205 + QUAD $0x3792f412cb06794d // .quad 4004531380238580045 + QUAD $0xcdb02555653131b6 // .quad -3625356651333078602 + QUAD $0xe2bbd88bbee40bd0 // .quad -2108853905778275376 + QUAD $0x808e17555f3ebf11 // .quad -9183376934724255983 + QUAD $0x5b6aceaeae9d0ec4 // .quad 6587304654631931588 + QUAD $0xa0b19d2ab70e6ed6 // .quad -6867535149977932074 + QUAD $0xf245825a5a445275 // .quad -989241218564861323 + QUAD $0xc8de047564d20a8b // .quad -3972732919045027189 + QUAD $0xeed6e2f0f0d56712 // .quad -1236551523206076654 + QUAD $0xfb158592be068d2e // .quad -354230130378896082 + QUAD $0x55464dd69685606b // .quad 6144684325637283947 + QUAD $0x9ced737bb6c4183d // .quad -7138922859127891907 + QUAD $0xaa97e14c3c26b886 // .quad -6154202648235558778 + QUAD $0xc428d05aa4751e4c // .quad -4311967555482476980 + QUAD $0xd53dd99f4b3066a8 // .quad -3081067291867060568 + QUAD $0xf53304714d9265df // .quad -778273425925708321 + QUAD $0xe546a8038efe4029 // .quad -1925667057416912855 + QUAD $0x993fe2c6d07b7fab // .quad -7403949918844649557 + QUAD $0xde98520472bdd033 // .quad -2407083821771141069 + QUAD $0xbf8fdb78849a5f96 // .quad -4643251380128424042 + QUAD $0x963e66858f6d4440 // .quad -7620540795641314240 + QUAD $0xef73d256a5c0f77c // .quad -1192378206733142148 + QUAD $0xdde7001379a44aa8 // .quad -2456994988062127448 + QUAD $0x95a8637627989aad // .quad -7662765406849295699 + QUAD $0x5560c018580d5d52 // .quad 6152128301777116498 + QUAD $0xbb127c53b17ec159 // .quad -4966770740134231719 + QUAD $0xaab8f01e6e10b4a6 // .quad -6144897678060768090 + QUAD $0xe9d71b689dde71af // .quad -1596777406740401745 + QUAD $0xcab3961304ca70e8 // .quad -3840561048787980056 + QUAD $0x9226712162ab070d // .quad -7915514906853832947 + QUAD $0x3d607b97c5fd0d22 // .quad 4422670725869800738 + QUAD $0xb6b00d69bb55c8d1 // .quad -5282707615139903279 + QUAD $0x8cb89a7db77c506a // .quad -8306719647944912790 + QUAD $0xe45c10c42a2b3b05 // .quad -1991698500497491195 + QUAD $0x77f3608e92adb242 // .quad 8643358275316593218 + QUAD $0x8eb98a7a9a5b04e3 // .quad -8162340590452013853 + QUAD $0x55f038b237591ed3 // .quad 6192511825718353619 + QUAD $0xb267ed1940f1c61c // .quad -5591239719637629412 + QUAD $0x6b6c46dec52f6688 // .quad 7740639782147942024 + QUAD $0xdf01e85f912e37a3 // .quad -2377363631119648861 + QUAD $0x2323ac4b3b3da015 // .quad 2532056854628769813 + QUAD $0x8b61313bbabce2c6 // .quad -8403381297090862394 + QUAD $0xabec975e0a0d081a // .quad -6058300968568813542 + QUAD $0xae397d8aa96c1b77 // .quad -5892540602936190089 + QUAD $0x96e7bd358c904a21 // .quad -7572876210711016927 + QUAD $0xd9c7dced53c72255 // .quad -2753989735242849707 + QUAD $0x7e50d64177da2e54 // .quad 9102010423587778132 + QUAD $0x881cea14545c7575 // .quad -8638772612167862923 + QUAD $0xdde50bd1d5d0b9e9 // .quad -2457545025797441047 + QUAD $0xaa242499697392d2 // .quad -6186779746782440750 + QUAD $0x955e4ec64b44e864 // .quad -7683617300674189212 + QUAD $0xd4ad2dbfc3d07787 // .quad -3121788665050663033 + QUAD $0xbd5af13bef0b113e // .quad -4802260812921368258 + QUAD $0x84ec3c97da624ab4 // .quad -8868646943297746252 + QUAD $0xecb1ad8aeacdd58e // .quad -1391139997724322418 + QUAD $0xa6274bbdd0fadd61 // .quad -6474122660694794911 + QUAD $0x67de18eda5814af2 // .quad 7484447039699372786 + QUAD $0xcfb11ead453994ba // .quad -3480967307441105734 + QUAD $0x80eacf948770ced7 // .quad -9157278655470055721 + QUAD $0x81ceb32c4b43fcf4 // .quad -9093133594791772940 + QUAD $0xa1258379a94d028d // .quad -6834912300910181747 + QUAD $0xa2425ff75e14fc31 // .quad -6754730975062328271 + QUAD $0x096ee45813a04330 // .quad 679731660717048624 + QUAD $0xcad2f7f5359a3b3e // .quad -3831727700400522434 + QUAD $0x8bca9d6e188853fc // .quad -8373707460958465028 + QUAD $0xfd87b5f28300ca0d // .quad -177973607073265139 + QUAD $0x775ea264cf55347d // .quad 8601490892183123069 + QUAD $0x9e74d1b791e07e48 // .quad -7028762532061872568 + QUAD $0x95364afe032a819d // .quad -7694880458480647779 + QUAD $0xc612062576589dda // .quad -4174267146649952806 + QUAD $0x3a83ddbd83f52204 // .quad 4216457482181353988 + QUAD $0xf79687aed3eec551 // .quad -606147914885053103 + QUAD $0xc4926a9672793542 // .quad -4282243101277735614 + QUAD $0x9abe14cd44753b52 // .quad -7296371474444240046 + QUAD $0x75b7053c0f178293 // .quad 8482254178684994195 + QUAD $0xc16d9a0095928a27 // .quad -4508778324627912153 + QUAD $0x5324c68b12dd6338 // .quad 5991131704928854840 + QUAD $0xf1c90080baf72cb1 // .quad -1024286887357502287 + QUAD $0xd3f6fc16ebca5e03 // .quad -3173071712060547581 + QUAD $0x971da05074da7bee // .quad -7557708332239520786 + QUAD $0x88f4bb1ca6bcf584 // .quad -8578025658503072380 + QUAD $0xbce5086492111aea // .quad -4835449396872013078 + QUAD $0x2b31e9e3d06c32e5 // .quad 3112525982153323237 + QUAD $0xec1e4a7db69561a5 // .quad -1432625727662628443 + QUAD $0x3aff322e62439fcf // .quad 4251171748059520975 + QUAD $0x9392ee8e921d5d07 // .quad -7812920107430224633 + QUAD $0x09befeb9fad487c2 // .quad 702278666647013314 + QUAD $0xb877aa3236a4b449 // .quad -5154464115860392887 + QUAD $0x4c2ebe687989a9b3 // .quad 5489534351736154547 + QUAD $0xe69594bec44de15b // .quad -1831394126398103205 + QUAD $0x0f9d37014bf60a10 // .quad 1125115960621402640 + QUAD $0x901d7cf73ab0acd9 // .quad -8062150356639896359 + QUAD $0x538484c19ef38c94 // .quad 6018080969204141204 + QUAD $0xb424dc35095cd80f // .quad -5466001927372482545 + QUAD $0x2865a5f206b06fb9 // .quad 2910915193077788601 + QUAD $0xe12e13424bb40e13 // .quad -2220816390788215277 + QUAD $0xf93f87b7442e45d3 // .quad -486521013540076077 + QUAD $0x8cbccc096f5088cb // .quad -8305539271883716405 + QUAD $0xf78f69a51539d748 // .quad -608151266925095096 + QUAD $0xafebff0bcb24aafe // .quad -5770238071427257602 + QUAD $0xb573440e5a884d1b // .quad -5371875102083756773 + QUAD $0xdbe6fecebdedd5be // .quad -2601111570856684098 + QUAD $0x31680a88f8953030 // .quad 3560107088838733872 + QUAD $0x89705f4136b4a597 // .quad -8543223759426509417 + QUAD $0xfdc20d2b36ba7c3d // .quad -161552157378970563 + QUAD $0xabcc77118461cefc // .quad -6067343680855748868 + QUAD $0x3d32907604691b4c // .quad 4409745821703674700 + QUAD $0xd6bf94d5e57a42bc // .quad -2972493582642298180 + QUAD $0xa63f9a49c2c1b10f // .quad -6467280898289979121 + QUAD $0x8637bd05af6c69b5 // .quad -8775337516792518219 + QUAD $0x0fcf80dc33721d53 // .quad 1139270913992301907 + QUAD $0xa7c5ac471b478423 // .quad -6357485877563259869 + QUAD $0xd3c36113404ea4a8 // .quad -3187597375937010520 + QUAD $0xd1b71758e219652b // .quad -3335171328526686933 + QUAD $0x645a1cac083126e9 // .quad 7231123676894144233 + QUAD $0x83126e978d4fdf3b // .quad -9002011107970261189 + QUAD $0x3d70a3d70a3d70a3 // .quad 4427218577690292387 + QUAD $0xa3d70a3d70a3d70a // .quad -6640827866535438582 + QUAD $0xcccccccccccccccc; QUAD $0xcccccccccccccccc // .space 16, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc' + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8000000000000000 // .quad -9223372036854775808 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa000000000000000 // .quad -6917529027641081856 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc800000000000000 // .quad -4035225266123964416 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xfa00000000000000 // .quad -432345564227567616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9c40000000000000 // .quad -7187745005283311616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc350000000000000 // .quad -4372995238176751616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xf424000000000000 // .quad -854558029293551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9896800000000000 // .quad -7451627795949551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xbebc200000000000 // .quad -4702848726509551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xee6b280000000000 // .quad -1266874889709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9502f90000000000 // .quad -7709325833709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xba43b74000000000 // .quad -5024971273709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe8d4a51000000000 // .quad -1669528073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9184e72a00000000 // .quad -7960984073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb5e620f480000000 // .quad -5339544073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe35fa931a0000000 // .quad -2062744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8ac7230489e80000 // .quad -8446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x878678326eac9000 // .quad -8681119073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa968163f0a57b400 // .quad -6239712823709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x84595161401484a0 // .quad -8910000909647051616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366 + QUAD $0x4000000000000000 // .quad 4611686018427387904 + QUAD $0x813f3978f8940984 // .quad -9133518327554766460 + QUAD $0x5000000000000000 // .quad 5764607523034234880 + QUAD $0xa18f07d736b90be5 // .quad -6805211891016070171 + QUAD $0xa400000000000000 // .quad -6629298651489370112 + QUAD $0xc9f2c9cd04674ede // .quad -3894828845342699810 + QUAD $0x4d00000000000000 // .quad 5548434740920451072 + QUAD $0xfc6f7c4045812296 // .quad -256850038250986858 + QUAD $0xf020000000000000 // .quad -1143914305352105984 + QUAD $0x9dc5ada82b70b59d // .quad -7078060301547948643 + QUAD $0x6c28000000000000 // .quad 7793479155164643328 + QUAD $0xc5371912364ce305 // .quad -4235889358507547899 + QUAD $0xc732000000000000 // .quad -4093209111326359552 + QUAD $0xf684df56c3e01bc6 // .quad -683175679707046970 + QUAD $0x3c7f400000000000 // .quad 4359273333062107136 + QUAD $0x9a130b963a6c115c // .quad -7344513827457986212 + QUAD $0x4b9f100000000000 // .quad 5449091666327633920 + QUAD $0xc097ce7bc90715b3 // .quad -4568956265895094861 + QUAD $0x1e86d40000000000 // .quad 2199678564482154496 + QUAD $0xf0bdc21abb48db20 // .quad -1099509313941480672 + QUAD $0x1314448000000000 // .quad 1374799102801346560 + QUAD $0x96769950b50d88f4 // .quad -7604722348854507276 + QUAD $0x17d955a000000000 // .quad 1718498878501683200 + QUAD $0xbc143fa4e250eb31 // .quad -4894216917640746191 + QUAD $0x5dcfab0800000000 // .quad 6759809616554491904 + QUAD $0xeb194f8e1ae525fd // .quad -1506085128623544835 + QUAD $0x5aa1cae500000000 // .quad 6530724019560251392 + QUAD $0x92efd1b8d0cf37be // .quad -7858832233030797378 + QUAD $0xf14a3d9e40000000 // .quad -1059967012404461568 + QUAD $0xb7abc627050305ad // .quad -5211854272861108819 + QUAD $0x6d9ccd05d0000000 // .quad 7898413271349198848 + QUAD $0xe596b7b0c643c719 // .quad -1903131822648998119 + QUAD $0xe4820023a2000000 // .quad -1981020733047832576 + QUAD $0x8f7e32ce7bea5c6f // .quad -8106986416796705681 + QUAD $0xdda2802c8a800000 // .quad -2476275916309790720 + QUAD $0xb35dbf821ae4f38b // .quad -5522047002568494197 + QUAD $0xd50b2037ad200000 // .quad -3095344895387238400 + QUAD $0xe0352f62a19e306e // .quad -2290872734783229842 + QUAD $0x4526f422cc340000 // .quad 4982938468024057856 + QUAD $0x8c213d9da502de45 // .quad -8349324486880600507 + QUAD $0x9670b12b7f410000 // .quad -7606384970252091392 + QUAD $0xaf298d050e4395d6 // .quad -5824969590173362730 + QUAD $0x3c0cdd765f114000 // .quad 4327076842467049472 + QUAD $0xdaf3f04651d47b4c // .quad -2669525969289315508 + QUAD $0xa5880a69fb6ac800 // .quad -6518949010312869888 + QUAD $0x88d8762bf324cd0f // .quad -8585982758446904049 + QUAD $0x8eea0d047a457a00 // .quad -8148686262891087360 + QUAD $0xab0e93b6efee0053 // .quad -6120792429631242157 + QUAD $0x72a4904598d6d880 // .quad 8260886245095692416 + QUAD $0xd5d238a4abe98068 // .quad -3039304518611664792 + QUAD $0x47a6da2b7f864750 // .quad 5163053903184807760 + QUAD $0x85a36366eb71f041 // .quad -8817094351773372351 + QUAD $0x999090b65f67d924 // .quad -7381240676301154012 + QUAD $0xa70c3c40a64e6c51 // .quad -6409681921289327535 + QUAD $0xfff4b4e3f741cf6d // .quad -3178808521666707 + QUAD $0xd0cf4b50cfe20765 // .quad -3400416383184271515 + QUAD $0xbff8f10e7a8921a4 // .quad -4613672773753429596 + QUAD $0x82818f1281ed449f // .quad -9042789267131251553 + QUAD $0xaff72d52192b6a0d // .quad -5767090967191786995 + QUAD $0xa321f2d7226895c7 // .quad -6691800565486676537 + QUAD $0x9bf4f8a69f764490 // .quad -7208863708989733744 + QUAD $0xcbea6f8ceb02bb39 // .quad -3753064688430957767 + QUAD $0x02f236d04753d5b4 // .quad 212292400617608628 + QUAD $0xfee50b7025c36a08 // .quad -79644842111309304 + QUAD $0x01d762422c946590 // .quad 132682750386005392 + QUAD $0x9f4f2726179a2245 // .quad -6967307053960650171 + QUAD $0x424d3ad2b7b97ef5 // .quad 4777539456409894645 + QUAD $0xc722f0ef9d80aad6 // .quad -4097447799023424810 + QUAD $0xd2e0898765a7deb2 // .quad -3251447716342407502 + QUAD $0xf8ebad2b84e0d58b // .quad -510123730351893109 + QUAD $0x63cc55f49f88eb2f // .quad 7191217214140771119 + QUAD $0x9b934c3b330c8577 // .quad -7236356359111015049 + QUAD $0x3cbf6b71c76b25fb // .quad 4377335499248575995 + QUAD $0xc2781f49ffcfa6d5 // .quad -4433759430461380907 + QUAD $0x8bef464e3945ef7a // .quad -8363388681221443718 + QUAD $0xf316271c7fc3908a // .quad -930513269649338230 + QUAD $0x97758bf0e3cbb5ac // .quad -7532960934977096276 + QUAD $0x97edd871cfda3a56 // .quad -7499099821171918250 + QUAD $0x3d52eeed1cbea317 // .quad 4418856886560793367 + QUAD $0xbde94e8e43d0c8ec // .quad -4762188758037509908 + QUAD $0x4ca7aaa863ee4bdd // .quad 5523571108200991709 + QUAD $0xed63a231d4c4fb27 // .quad -1341049929119499481 + QUAD $0x8fe8caa93e74ef6a // .quad -8076983103442849942 + QUAD $0x945e455f24fb1cf8 // .quad -7755685233340769032 + QUAD $0xb3e2fd538e122b44 // .quad -5484542860876174524 + QUAD $0xb975d6b6ee39e436 // .quad -5082920523248573386 + QUAD $0x60dbbca87196b616 // .quad 6979379479186945558 + QUAD $0xe7d34c64a9c85d44 // .quad -1741964635633328828 + QUAD $0xbc8955e946fe31cd // .quad -4861259862362934835 + QUAD $0x90e40fbeea1d3a4a // .quad -8006256924911912374 + QUAD $0x6babab6398bdbe41 // .quad 7758483227328495169 + QUAD $0xb51d13aea4a488dd // .quad -5396135137712502563 + QUAD $0xc696963c7eed2dd1 // .quad -4136954021121544751 + QUAD $0xe264589a4dcdab14 // .quad -2133482903713240300 + QUAD $0xfc1e1de5cf543ca2 // .quad -279753253987271518 + QUAD $0x8d7eb76070a08aec // .quad -8250955842461857044 + QUAD $0x3b25a55f43294bcb // .quad 4261994450943298507 + QUAD $0xb0de65388cc8ada8 // .quad -5702008784649933400 + QUAD $0x49ef0eb713f39ebe // .quad 5327493063679123134 + QUAD $0xdd15fe86affad912 // .quad -2515824962385028846 + QUAD $0x6e3569326c784337 // .quad 7941369183226839863 + QUAD $0x8a2dbf142dfcc7ab // .quad -8489919629131724885 + QUAD $0x49c2c37f07965404 // .quad 5315025460606161924 + QUAD $0xacb92ed9397bf996 // .quad -6000713517987268202 + QUAD $0xdc33745ec97be906 // .quad -2579590211097073402 + QUAD $0xd7e77a8f87daf7fb // .quad -2889205879056697349 + QUAD $0x69a028bb3ded71a3 // .quad 7611128154919104931 + QUAD $0x86f0ac99b4e8dafd // .quad -8723282702051517699 + QUAD $0xc40832ea0d68ce0c // .quad -4321147861633282548 + QUAD $0xa8acd7c0222311bc // .quad -6292417359137009220 + QUAD $0xf50a3fa490c30190 // .quad -789748808614215280 + QUAD $0xd2d80db02aabd62b // .quad -3253835680493873621 + QUAD $0x792667c6da79e0fa // .quad 8729779031470891258 + QUAD $0x83c7088e1aab65db // .quad -8951176327949752869 + QUAD $0x577001b891185938 // .quad 6300537770911226168 + QUAD $0xa4b8cab1a1563f52 // .quad -6577284391509803182 + QUAD $0xed4c0226b55e6f86 // .quad -1347699823215743098 + QUAD $0xcde6fd5e09abcf26 // .quad -3609919470959866074 + QUAD $0x544f8158315b05b4 // .quad 6075216638131242420 + QUAD $0x80b05e5ac60b6178 // .quad -9173728696990998152 + QUAD $0x696361ae3db1c721 // .quad 7594020797664053025 + QUAD $0xa0dc75f1778e39d6 // .quad -6855474852811359786 + QUAD $0x03bc3a19cd1e38e9 // .quad 269153960225290473 + QUAD $0xc913936dd571c84c // .quad -3957657547586811828 + QUAD $0x04ab48a04065c723 // .quad 336442450281613091 + QUAD $0xfb5878494ace3a5f // .quad -335385916056126881 + QUAD $0x62eb0d64283f9c76 // .quad 7127805559067090038 + QUAD $0x9d174b2dcec0e47b // .quad -7127145225176161157 + QUAD $0x3ba5d0bd324f8394 // .quad 4298070930406474644 + QUAD $0xc45d1df942711d9a // .quad -4297245513042813542 + QUAD $0xca8f44ec7ee36479 // .quad -3850783373846682503 + QUAD $0xf5746577930d6500 // .quad -759870872876129024 + QUAD $0x7e998b13cf4e1ecb // .quad 9122475437414293195 + QUAD $0x9968bf6abbe85f20 // .quad -7392448323188662496 + QUAD $0x9e3fedd8c321a67e // .quad -7043649776941685122 + QUAD $0xbfc2ef456ae276e8 // .quad -4628874385558440216 + QUAD $0xc5cfe94ef3ea101e // .quad -4192876202749718498 + QUAD $0xefb3ab16c59b14a2 // .quad -1174406963520662366 + QUAD $0xbba1f1d158724a12 // .quad -4926390635932268014 + QUAD $0x95d04aee3b80ece5 // .quad -7651533379841495835 + QUAD $0x2a8a6e45ae8edc97 // .quad 3065383741939440791 + QUAD $0xbb445da9ca61281f // .quad -4952730706374481889 + QUAD $0xf52d09d71a3293bd // .quad -779956341003086915 + QUAD $0xea1575143cf97226 // .quad -1579227364540714458 + QUAD $0x593c2626705f9c56 // .quad 6430056314514152534 + QUAD $0x924d692ca61be758 // .quad -7904546130479028392 + QUAD $0x6f8b2fb00c77836c // .quad 8037570393142690668 + QUAD $0xb6e0c377cfa2e12e // .quad -5268996644671397586 + QUAD $0x0b6dfb9c0f956447 // .quad 823590954573587527 + QUAD $0xe498f455c38b997a // .quad -1974559787411859078 + QUAD $0x4724bd4189bd5eac // .quad 5126430365035880108 + QUAD $0x8edf98b59a373fec // .quad -8151628894773493780 + QUAD $0x58edec91ec2cb657 // .quad 6408037956294850135 + QUAD $0xb2977ee300c50fe7 // .quad -5577850100039479321 + QUAD $0x2f2967b66737e3ed // .quad 3398361426941174765 + QUAD $0xdf3d5e9bc0f653e1 // .quad -2360626606621961247 + QUAD $0xbd79e0d20082ee74 // .quad -4793553135802847628 + QUAD $0x8b865b215899f46c // .quad -8392920656779807636 + QUAD $0xecd8590680a3aa11 // .quad -1380255401326171631 + QUAD $0xae67f1e9aec07187 // .quad -5879464802547371641 + QUAD $0xe80e6f4820cc9495 // .quad -1725319251657714539 + QUAD $0xda01ee641a708de9 // .quad -2737644984756826647 + QUAD $0x3109058d147fdcdd // .quad 3533361486141316317 + QUAD $0x884134fe908658b2 // .quad -8628557143114098510 + QUAD $0xbd4b46f0599fd415 // .quad -4806670179178130411 + QUAD $0xaa51823e34a7eede // .quad -6174010410465235234 + QUAD $0x6c9e18ac7007c91a // .quad 7826720331309500698 + QUAD $0xd4e5e2cdc1d1ea96 // .quad -3105826994654156138 + QUAD $0x03e2cf6bc604ddb0 // .quad 280014188641050032 + QUAD $0x850fadc09923329e // .quad -8858670899299929442 + QUAD $0x84db8346b786151c // .quad -8873354301053463268 + QUAD $0xa6539930bf6bff45 // .quad -6461652605697523899 + QUAD $0xe612641865679a63 // .quad -1868320839462053277 + QUAD $0xcfe87f7cef46ff16 // .quad -3465379738694516970 + QUAD $0x4fcb7e8f3f60c07e // .quad 5749828502977298558 + QUAD $0x81f14fae158c5f6e // .quad -9083391364325154962 + QUAD $0xe3be5e330f38f09d // .quad -2036086408133152611 + QUAD $0xa26da3999aef7749 // .quad -6742553186979055799 + QUAD $0x5cadf5bfd3072cc5 // .quad 6678264026688335045 + QUAD $0xcb090c8001ab551c // .quad -3816505465296431844 + QUAD $0x73d9732fc7c8f7f6 // .quad 8347830033360418806 + QUAD $0xfdcb4fa002162a63 // .quad -158945813193151901 + QUAD $0x2867e7fddcdd9afa // .quad 2911550761636567802 + QUAD $0x9e9f11c4014dda7e // .quad -7016870160886801794 + QUAD $0xb281e1fd541501b8 // .quad -5583933584809066056 + QUAD $0xc646d63501a1511d // .quad -4159401682681114339 + QUAD $0x1f225a7ca91a4226 // .quad 2243455055843443238 + QUAD $0xf7d88bc24209a565 // .quad -587566084924005019 + QUAD $0x3375788de9b06958 // .quad 3708002419115845976 + QUAD $0x9ae757596946075f // .quad -7284757830718584993 + QUAD $0x0052d6b1641c83ae // .quad 23317005467419566 + QUAD $0xc1a12d2fc3978937 // .quad -4494261269970843337 + QUAD $0xc0678c5dbd23a49a // .quad -4582539761593113446 + QUAD $0xf209787bb47d6b84 // .quad -1006140569036166268 + QUAD $0xf840b7ba963646e0 // .quad -558244341782001952 + QUAD $0x9745eb4d50ce6332 // .quad -7546366883288685774 + QUAD $0xb650e5a93bc3d898 // .quad -5309491445654890344 + QUAD $0xbd176620a501fbff // .quad -4821272585683469313 + QUAD $0xa3e51f138ab4cebe // .quad -6636864307068612930 + QUAD $0xec5d3fa8ce427aff // .quad -1414904713676948737 + QUAD $0xc66f336c36b10137 // .quad -4148040191917883081 + QUAD $0x93ba47c980e98cdf // .quad -7801844473689174817 + QUAD $0xb80b0047445d4184 // .quad -5185050239897353852 + QUAD $0xb8a8d9bbe123f017 // .quad -5140619573684080617 + QUAD $0xa60dc059157491e5 // .quad -6481312799871692315 + QUAD $0xe6d3102ad96cec1d // .quad -1814088448677712867 + QUAD $0x87c89837ad68db2f // .quad -8662506518347195601 + QUAD $0x9043ea1ac7e41392 // .quad -8051334308064652398 + QUAD $0x29babe4598c311fb // .quad 3006924907348169211 + QUAD $0xb454e4a179dd1877 // .quad -5452481866653427593 + QUAD $0xf4296dd6fef3d67a // .quad -853029884242176390 + QUAD $0xe16a1dc9d8545e94 // .quad -2203916314889396588 + QUAD $0x1899e4a65f58660c // .quad 1772699331562333708 + QUAD $0x8ce2529e2734bb1d // .quad -8294976724446954723 + QUAD $0x5ec05dcff72e7f8f // .quad 6827560182880305039 + QUAD $0xb01ae745b101e9e4 // .quad -5757034887131305500 + QUAD $0x76707543f4fa1f73 // .quad 8534450228600381299 + QUAD $0xdc21a1171d42645d // .quad -2584607590486743971 + QUAD $0x6a06494a791c53a8 // .quad 7639874402088932264 + QUAD $0x899504ae72497eba // .quad -8532908771695296838 + QUAD $0x0487db9d17636892 // .quad 326470965756389522 + QUAD $0xabfa45da0edbde69 // .quad -6054449946191733143 + QUAD $0x45a9d2845d3c42b6 // .quad 5019774725622874806 + QUAD $0xd6f8d7509292d603 // .quad -2956376414312278525 + QUAD $0x0b8a2392ba45a9b2 // .quad 831516194300602802 + QUAD $0x865b86925b9bc5c2 // .quad -8765264286586255934 + QUAD $0x8e6cac7768d7141e // .quad -8183976793979022306 + QUAD $0xa7f26836f282b732 // .quad -6344894339805432014 + QUAD $0x3207d795430cd926 // .quad 3605087062808385830 + QUAD $0xd1ef0244af2364ff // .quad -3319431906329402113 + QUAD $0x7f44e6bd49e807b8 // .quad 9170708441896323000 + QUAD $0x8335616aed761f1f // .quad -8992173969096958177 + QUAD $0x5f16206c9c6209a6 // .quad 6851699533943015846 + QUAD $0xa402b9c5a8d3a6e7 // .quad -6628531442943809817 + QUAD $0x36dba887c37a8c0f // .quad 3952938399001381903 + QUAD $0xcd036837130890a1 // .quad -3673978285252374367 + QUAD $0xc2494954da2c9789 // .quad -4446942528265218167 + QUAD $0x802221226be55a64 // .quad -9213765455923815836 + QUAD $0xf2db9baa10b7bd6c // .quad -946992141904134804 + QUAD $0xa02aa96b06deb0fd // .quad -6905520801477381891 + QUAD $0x6f92829494e5acc7 // .quad 8039631859474607303 + QUAD $0xc83553c5c8965d3d // .quad -4020214983419339459 + QUAD $0xcb772339ba1f17f9 // .quad -3785518230938904583 + QUAD $0xfa42a8b73abbf48c // .quad -413582710846786420 + QUAD $0xff2a760414536efb // .quad -60105885123121413 + QUAD $0x9c69a97284b578d7 // .quad -7176018221920323369 + QUAD $0xfef5138519684aba // .quad -75132356403901766 + QUAD $0xc38413cf25e2d70d // .quad -4358336758973016307 + QUAD $0x7eb258665fc25d69 // .quad 9129456591349898601 + QUAD $0xf46518c2ef5b8cd1 // .quad -836234930288882479 + QUAD $0xef2f773ffbd97a61 // .quad -1211618658047395231 + QUAD $0x98bf2f79d5993802 // .quad -7440175859071633406 + QUAD $0xaafb550ffacfd8fa // .quad -6126209340986631942 + QUAD $0xbeeefb584aff8603 // .quad -4688533805412153853 + QUAD $0x95ba2a53f983cf38 // .quad -7657761676233289928 + QUAD $0xeeaaba2e5dbf6784 // .quad -1248981238337804412 + QUAD $0xdd945a747bf26183 // .quad -2480258038432112253 + QUAD $0x952ab45cfa97a0b2 // .quad -7698142301602209614 + QUAD $0x94f971119aeef9e4 // .quad -7712008566467528220 + QUAD $0xba756174393d88df // .quad -5010991858575374113 + QUAD $0x7a37cd5601aab85d // .quad 8806733365625141341 + QUAD $0xe912b9d1478ceb17 // .quad -1652053804791829737 + QUAD $0xac62e055c10ab33a // .quad -6025006692552756422 + QUAD $0x91abb422ccb812ee // .quad -7950062655635975442 + QUAD $0x577b986b314d6009 // .quad 6303799689591218185 + QUAD $0xb616a12b7fe617aa // .quad -5325892301117581398 + QUAD $0xed5a7e85fda0b80b // .quad -1343622424865753077 + QUAD $0xe39c49765fdf9d94 // .quad -2045679357969588844 + QUAD $0x14588f13be847307 // .quad 1466078993672598279 + QUAD $0x8e41ade9fbebc27d // .quad -8196078626372074883 + QUAD $0x596eb2d8ae258fc8 // .quad 6444284760518135752 + QUAD $0xb1d219647ae6b31c // .quad -5633412264537705700 + QUAD $0x6fca5f8ed9aef3bb // .quad 8055355950647669691 + QUAD $0xde469fbd99a05fe3 // .quad -2430079312244744221 + QUAD $0x25de7bb9480d5854 // .quad 2728754459941099604 + QUAD $0x8aec23d680043bee // .quad -8436328597794046994 + QUAD $0xaf561aa79a10ae6a // .quad -5812428961928401302 + QUAD $0xada72ccc20054ae9 // .quad -5933724728815170839 + QUAD $0x1b2ba1518094da04 // .quad 1957835834444274180 + QUAD $0xd910f7ff28069da4 // .quad -2805469892591575644 + QUAD $0x90fb44d2f05d0842 // .quad -7999724640327104446 + QUAD $0x87aa9aff79042286 // .quad -8670947710510816634 + QUAD $0x353a1607ac744a53 // .quad 3835402254873283155 + QUAD $0xa99541bf57452b28 // .quad -6226998619711132888 + QUAD $0x42889b8997915ce8 // .quad 4794252818591603944 + QUAD $0xd3fa922f2d1675f2 // .quad -3172062256211528206 + QUAD $0x69956135febada11 // .quad 7608094030047140369 + QUAD $0x847c9b5d7c2e09b7 // .quad -8900067937773286985 + QUAD $0x43fab9837e699095 // .quad 4898431519131537557 + QUAD $0xa59bc234db398c25 // .quad -6513398903789220827 + QUAD $0x94f967e45e03f4bb // .quad -7712018656367741765 + QUAD $0xcf02b2c21207ef2e // .quad -3530062611309138130 + QUAD $0x1d1be0eebac278f5 // .quad 2097517367411243253 + QUAD $0x8161afb94b44f57d // .quad -9123818159709293187 + QUAD $0x6462d92a69731732 // .quad 7233582727691441970 + QUAD $0xa1ba1ba79e1632dc // .quad -6793086681209228580 + QUAD $0x7d7b8f7503cfdcfe // .quad 9041978409614302462 + QUAD $0xca28a291859bbf93 // .quad -3879672333084147821 + QUAD $0x5cda735244c3d43e // .quad 6690786993590490174 + QUAD $0xfcb2cb35e702af78 // .quad -237904397927796872 + QUAD $0x3a0888136afa64a7 // .quad 4181741870994056359 + QUAD $0x9defbf01b061adab // .quad -7066219276345954901 + QUAD $0x088aaa1845b8fdd0 // .quad 615491320315182544 + QUAD $0xc56baec21c7a1916 // .quad -4221088077005055722 + QUAD $0x8aad549e57273d45 // .quad -8454007886460797627 + QUAD $0xf6c69a72a3989f5b // .quad -664674077828931749 + QUAD $0x36ac54e2f678864b // .quad 3939617107816777291 + QUAD $0x9a3c2087a63f6399 // .quad -7332950326284164199 + QUAD $0x84576a1bb416a7dd // .quad -8910536670511192099 + QUAD $0xc0cb28a98fcf3c7f // .quad -4554501889427817345 + QUAD $0x656d44a2a11c51d5 // .quad 7308573235570561493 + QUAD $0xf0fdf2d3f3c30b9f // .quad -1081441343357383777 + QUAD $0x9f644ae5a4b1b325 // .quad -6961356773836868827 + QUAD $0x969eb7c47859e743 // .quad -7593429867239446717 + QUAD $0x873d5d9f0dde1fee // .quad -8701695967296086034 + QUAD $0xbc4665b596706114 // .quad -4880101315621920492 + QUAD $0xa90cb506d155a7ea // .quad -6265433940692719638 + QUAD $0xeb57ff22fc0c7959 // .quad -1488440626100012711 + QUAD $0x09a7f12442d588f2 // .quad 695789805494438130 + QUAD $0x9316ff75dd87cbd8 // .quad -7847804418953589800 + QUAD $0x0c11ed6d538aeb2f // .quad 869737256868047663 + QUAD $0xb7dcbf5354e9bece // .quad -5198069505264599346 + QUAD $0x8f1668c8a86da5fa // .quad -8136200465769716230 + QUAD $0xe5d3ef282a242e81 // .quad -1885900863153361279 + QUAD $0xf96e017d694487bc // .quad -473439272678684740 + QUAD $0x8fa475791a569d10 // .quad -8096217067111932656 + QUAD $0x37c981dcc395a9ac // .quad 4019886927579031980 + QUAD $0xb38d92d760ec4455 // .quad -5508585315462527915 + QUAD $0x85bbe253f47b1417 // .quad -8810199395808373737 + QUAD $0xe070f78d3927556a // .quad -2274045625900771990 + QUAD $0x93956d7478ccec8e // .quad -7812217631593927538 + QUAD $0x8c469ab843b89562 // .quad -8338807543829064350 + QUAD $0x387ac8d1970027b2 // .quad 4069786015789754290 + QUAD $0xaf58416654a6babb // .quad -5811823411358942533 + QUAD $0x06997b05fcc0319e // .quad 475546501309804958 + QUAD $0xdb2e51bfe9d0696a // .quad -2653093245771290262 + QUAD $0x441fece3bdf81f03 // .quad 4908902581746016003 + QUAD $0x88fcf317f22241e2 // .quad -8575712306248138270 + QUAD $0xd527e81cad7626c3 // .quad -3087243809672255805 + QUAD $0xab3c2fddeeaad25a // .quad -6107954364382784934 + QUAD $0x8a71e223d8d3b074 // .quad -8470740780517707660 + QUAD $0xd60b3bd56a5586f1 // .quad -3023256937051093263 + QUAD $0xf6872d5667844e49 // .quad -682526969396179383 + QUAD $0x85c7056562757456 // .quad -8807064613298015146 + QUAD $0xb428f8ac016561db // .quad -5464844730172612133 + QUAD $0xa738c6bebb12d16c // .quad -6397144748195131028 + QUAD $0xe13336d701beba52 // .quad -2219369894288377262 + QUAD $0xd106f86e69d785c7 // .quad -3384744916816525881 + QUAD $0xecc0024661173473 // .quad -1387106183930235789 + QUAD $0x82a45b450226b39c // .quad -9032994600651410532 + QUAD $0x27f002d7f95d0190 // .quad 2877803288514593168 + QUAD $0xa34d721642b06084 // .quad -6679557232386875260 + QUAD $0x31ec038df7b441f4 // .quad 3597254110643241460 + QUAD $0xcc20ce9bd35c78a5 // .quad -3737760522056206171 + QUAD $0x7e67047175a15271 // .quad 9108253656731439729 + QUAD $0xff290242c83396ce // .quad -60514634142869810 + QUAD $0x0f0062c6e984d386 // .quad 1080972517029761926 + QUAD $0x9f79a169bd203e41 // .quad -6955350673980375487 + QUAD $0x52c07b78a3e60868 // .quad 5962901664714590312 + QUAD $0xc75809c42c684dd1 // .quad -4082502324048081455 + QUAD $0xa7709a56ccdf8a82 // .quad -6381430974388925822 + QUAD $0xf92e0c3537826145 // .quad -491441886632713915 + QUAD $0x88a66076400bb691 // .quad -8600080377420466543 + QUAD $0x9bbcc7a142b17ccb // .quad -7224680206786528053 + QUAD $0x6acff893d00ea435 // .quad 7696643601933968437 + QUAD $0xc2abf989935ddbfe // .quad -4419164240055772162 + QUAD $0x0583f6b8c4124d43 // .quad 397432465562684739 + QUAD $0xf356f7ebf83552fe // .quad -912269281642327298 + QUAD $0xc3727a337a8b704a // .quad -4363290727450709942 + QUAD $0x98165af37b2153de // .quad -7487697328667536418 + QUAD $0x744f18c0592e4c5c // .quad 8380944645968776284 + QUAD $0xbe1bf1b059e9a8d6 // .quad -4747935642407032618 + QUAD $0x1162def06f79df73 // .quad 1252808770606194547 + QUAD $0xeda2ee1c7064130c // .quad -1323233534581402868 + QUAD $0x8addcb5645ac2ba8 // .quad -8440366555225904216 + QUAD $0x9485d4d1c63e8be7 // .quad -7744549986754458649 + QUAD $0x6d953e2bd7173692 // .quad 7896285879677171346 + QUAD $0xb9a74a0637ce2ee1 // .quad -5069001465015685407 + QUAD $0xc8fa8db6ccdd0437 // .quad -3964700705685699529 + QUAD $0xe8111c87c5c1ba99 // .quad -1724565812842218855 + QUAD $0x1d9c9892400a22a2 // .quad 2133748077373825698 + QUAD $0x910ab1d4db9914a0 // .quad -7995382660667468640 + QUAD $0x2503beb6d00cab4b // .quad 2667185096717282123 + QUAD $0xb54d5e4a127f59c8 // .quad -5382542307406947896 + QUAD $0x2e44ae64840fd61d // .quad 3333981370896602653 + QUAD $0xe2a0b5dc971f303a // .quad -2116491865831296966 + QUAD $0x5ceaecfed289e5d2 // .quad 6695424375237764562 + QUAD $0x8da471a9de737e24 // .quad -8240336443785642460 + QUAD $0x7425a83e872c5f47 // .quad 8369280469047205703 + QUAD $0xb10d8e1456105dad // .quad -5688734536304665171 + QUAD $0xd12f124e28f77719 // .quad -3373457468973156583 + QUAD $0xdd50f1996b947518 // .quad -2499232151953443560 + QUAD $0x82bd6b70d99aaa6f // .quad -9025939945749304721 + QUAD $0x8a5296ffe33cc92f // .quad -8479549122611984081 + QUAD $0x636cc64d1001550b // .quad 7164319141522920715 + QUAD $0xace73cbfdc0bfb7b // .quad -5987750384837592197 + QUAD $0x3c47f7e05401aa4e // .quad 4343712908476262990 + QUAD $0xd8210befd30efa5a // .quad -2873001962619602342 + QUAD $0x65acfaec34810a71 // .quad 7326506586225052273 + QUAD $0x8714a775e3e95c78 // .quad -8713155254278333320 + QUAD $0x7f1839a741a14d0d // .quad 9158133232781315341 + QUAD $0xa8d9d1535ce3b396 // .quad -6279758049420528746 + QUAD $0x1ede48111209a050 // .quad 2224294504121868368 + QUAD $0xd31045a8341ca07c // .quad -3238011543348273028 + QUAD $0x934aed0aab460432 // .quad -7833187971778608078 + QUAD $0x83ea2b892091e44d // .quad -8941286242233752499 + QUAD $0xf81da84d5617853f // .quad -568112927868484289 + QUAD $0xa4e4b66b68b65d60 // .quad -6564921784364802720 + QUAD $0x36251260ab9d668e // .quad 3901544858591782542 + QUAD $0xce1de40642e3f4b9 // .quad -3594466212028615495 + QUAD $0xc1d72b7c6b426019 // .quad -4479063491021217767 + QUAD $0x80d2ae83e9ce78f3 // .quad -9164070410158966541 + QUAD $0xb24cf65b8612f81f // .quad -5598829363776522209 + QUAD $0xa1075a24e4421730 // .quad -6843401994271320272 + QUAD $0xdee033f26797b627 // .quad -2386850686293264857 + QUAD $0xc94930ae1d529cfc // .quad -3942566474411762436 + QUAD $0x169840ef017da3b1 // .quad 1628122660560806833 + QUAD $0xfb9b7cd9a4a7443c // .quad -316522074587315140 + QUAD $0x8e1f289560ee864e // .quad -8205795374004271538 + QUAD $0x9d412e0806e88aa5 // .quad -7115355324258153819 + QUAD $0xf1a6f2bab92a27e2 // .quad -1033872180650563614 + QUAD $0xc491798a08a2ad4e // .quad -4282508136895304370 + QUAD $0xae10af696774b1db // .quad -5904026244240592421 + QUAD $0xf5b5d7ec8acb58a2 // .quad -741449152691742558 + QUAD $0xacca6da1e0a8ef29 // .quad -5995859411864064215 + QUAD $0x9991a6f3d6bf1765 // .quad -7380934748073420955 + QUAD $0x17fd090a58d32af3 // .quad 1728547772024695539 + QUAD $0xbff610b0cc6edd3f // .quad -4614482416664388289 + QUAD $0xddfc4b4cef07f5b0 // .quad -2451001303396518480 + QUAD $0xeff394dcff8a948e // .quad -1156417002403097458 + QUAD $0x4abdaf101564f98e // .quad 5385653213018257806 + QUAD $0x95f83d0a1fb69cd9 // .quad -7640289654143017767 + QUAD $0x9d6d1ad41abe37f1 // .quad -7102991539009341455 + QUAD $0xbb764c4ca7a4440f // .quad -4938676049251384305 + QUAD $0x84c86189216dc5ed // .quad -8878739423761676819 + QUAD $0xea53df5fd18d5513 // .quad -1561659043136842477 + QUAD $0x32fd3cf5b4e49bb4 // .quad 3674159897003727796 + QUAD $0x92746b9be2f8552c // .quad -7893565929601608404 + QUAD $0x3fbc8c33221dc2a1 // .quad 4592699871254659745 + QUAD $0xb7118682dbb66a77 // .quad -5255271393574622601 + QUAD $0x0fabaf3feaa5334a // .quad 1129188820640936778 + QUAD $0xe4d5e82392a40515 // .quad -1957403223540890347 + QUAD $0x29cb4d87f2a7400e // .quad 3011586022114279438 + QUAD $0x8f05b1163ba6832d // .quad -8140906042354138323 + QUAD $0x743e20e9ef511012 // .quad 8376168546070237202 + QUAD $0xb2c71d5bca9023f8 // .quad -5564446534515285000 + QUAD $0x914da9246b255416 // .quad -7976533391121755114 + QUAD $0xdf78e4b2bd342cf6 // .quad -2343872149716718346 + QUAD $0x1ad089b6c2f7548e // .quad 1932195658189984910 + QUAD $0x8bab8eefb6409c1a // .quad -8382449121214030822 + QUAD $0xa184ac2473b529b1 // .quad -6808127464117294671 + QUAD $0xae9672aba3d0c320 // .quad -5866375383090150624 + QUAD $0xc9e5d72d90a2741e // .quad -3898473311719230434 + QUAD $0xda3c0f568cc4f3e8 // .quad -2721283210435300376 + QUAD $0x7e2fa67c7a658892 // .quad 9092669226243950738 + QUAD $0x8865899617fb1871 // .quad -8618331034163144591 + QUAD $0xddbb901b98feeab7 // .quad -2469221522477225289 + QUAD $0xaa7eebfb9df9de8d // .quad -6161227774276542835 + QUAD $0x552a74227f3ea565 // .quad 6136845133758244197 + QUAD $0xd51ea6fa85785631 // .quad -3089848699418290639 + QUAD $0xd53a88958f87275f // .quad -3082000819042179233 + QUAD $0x8533285c936b35de // .quad -8848684464777513506 + QUAD $0x8a892abaf368f137 // .quad -8464187042230111945 + QUAD $0xa67ff273b8460356 // .quad -6449169562544503978 + QUAD $0x2d2b7569b0432d85 // .quad 3254824252494523781 + QUAD $0xd01fef10a657842c // .quad -3449775934753242068 + QUAD $0x9c3b29620e29fc73 // .quad -7189106879045698445 + QUAD $0x8213f56a67f6b29b // .quad -9073638986861858149 + QUAD $0x8349f3ba91b47b8f // .quad -8986383598807123057 + QUAD $0xa298f2c501f45f42 // .quad -6730362715149934782 + QUAD $0x241c70a936219a73 // .quad 2602078556773259891 + QUAD $0xcb3f2f7642717713 // .quad -3801267375510030573 + QUAD $0xed238cd383aa0110 // .quad -1359087822460813040 + QUAD $0xfe0efb53d30dd4d7 // .quad -139898200960150313 + QUAD $0xf4363804324a40aa // .quad -849429889038008150 + QUAD $0x9ec95d1463e8a506 // .quad -7004965403241175802 + QUAD $0xb143c6053edcd0d5 // .quad -5673473379724898091 + QUAD $0xc67bb4597ce2ce48 // .quad -4144520735624081848 + QUAD $0xdd94b7868e94050a // .quad -2480155706228734710 + QUAD $0xf81aa16fdc1b81da // .quad -568964901102714406 + QUAD $0xca7cf2b4191c8326 // .quad -3855940325606653146 + QUAD $0x9b10a4e5e9913128 // .quad -7273132090830278360 + QUAD $0xfd1c2f611f63a3f0 // .quad -208239388580928528 + QUAD $0xc1d4ce1f63f57d72 // .quad -4479729095110460046 + QUAD $0xbc633b39673c8cec // .quad -4871985254153548564 + QUAD $0xf24a01a73cf2dccf // .quad -987975350460687153 + QUAD $0xd5be0503e085d813 // .quad -3044990783845967853 + QUAD $0x976e41088617ca01 // .quad -7535013621679011327 + QUAD $0x4b2d8644d8a74e18 // .quad 5417133557047315992 + QUAD $0xbd49d14aa79dbc82 // .quad -4807081008671376254 + QUAD $0xddf8e7d60ed1219e // .quad -2451955090545630818 + QUAD $0xec9c459d51852ba2 // .quad -1397165242411832414 + QUAD $0xcabb90e5c942b503 // .quad -3838314940804713213 + QUAD $0x93e1ab8252f33b45 // .quad -7790757304148477115 + QUAD $0x3d6a751f3b936243 // .quad 4425478360848884291 + QUAD $0xb8da1662e7b00a17 // .quad -5126760611758208489 + QUAD $0x0cc512670a783ad4 // .quad 920161932633717460 + QUAD $0xe7109bfba19c0c9d // .quad -1796764746270372707 + QUAD $0x27fb2b80668b24c5 // .quad 2880944217109767365 + QUAD $0x906a617d450187e2 // .quad -8040506994060064798 + QUAD $0xb1f9f660802dedf6 // .quad -5622191765467566602 + QUAD $0xb484f9dc9641e9da // .quad -5438947724147693094 + QUAD $0x5e7873f8a0396973 // .quad 6807318348447705459 + QUAD $0xe1a63853bbd26451 // .quad -2186998636757228463 + QUAD $0xdb0b487b6423e1e8 // .quad -2662955059861265944 + QUAD $0x8d07e33455637eb2 // .quad -8284403175614349646 + QUAD $0x91ce1a9a3d2cda62 // .quad -7940379843253970334 + QUAD $0xb049dc016abc5e5f // .quad -5743817951090549153 + QUAD $0x7641a140cc7810fb // .quad 8521269269642088699 + QUAD $0xdc5c5301c56b75f7 // .quad -2568086420435798537 + QUAD $0xa9e904c87fcb0a9d // .quad -6203421752542164323 + QUAD $0x89b9b3e11b6329ba // .quad -8522583040413455942 + QUAD $0x546345fa9fbdcd44 // .quad 6080780864604458308 + QUAD $0xac2820d9623bf429 // .quad -6041542782089432023 + QUAD $0xa97c177947ad4095 // .quad -6234081974526590827 + QUAD $0xd732290fbacaf133 // .quad -2940242459184402125 + QUAD $0x49ed8eabcccc485d // .quad 5327070802775656541 + QUAD $0x867f59a9d4bed6c0 // .quad -8755180564631333184 + QUAD $0x5c68f256bfff5a74 // .quad 6658838503469570676 + QUAD $0xa81f301449ee8c70 // .quad -6332289687361778576 + QUAD $0x73832eec6fff3111 // .quad 8323548129336963345 + QUAD $0xd226fc195c6a2f8c // .quad -3303676090774835316 + QUAD $0xc831fd53c5ff7eab // .quad -4021154456019173717 + QUAD $0x83585d8fd9c25db7 // .quad -8982326584375353929 + QUAD $0xba3e7ca8b77f5e55 // .quad -5026443070023967147 + QUAD $0xa42e74f3d032f525 // .quad -6616222212041804507 + QUAD $0x28ce1bd2e55f35eb // .quad 2940318199324816875 + QUAD $0xcd3a1230c43fb26f // .quad -3658591746624867729 + QUAD $0x7980d163cf5b81b3 // .quad 8755227902219092403 + QUAD $0x80444b5e7aa7cf85 // .quad -9204148869281624187 + QUAD $0xd7e105bcc332621f // .quad -2891023177508298209 + QUAD $0xa0555e361951c366 // .quad -6893500068174642330 + QUAD $0x8dd9472bf3fefaa7 // .quad -8225464990312760665 + QUAD $0xc86ab5c39fa63440 // .quad -4005189066790915008 + QUAD $0xb14f98f6f0feb951 // .quad -5670145219463562927 + QUAD $0xfa856334878fc150 // .quad -394800315061255856 + QUAD $0x6ed1bf9a569f33d3 // .quad 7985374283903742931 + QUAD $0x9c935e00d4b9d8d2 // .quad -7164279224554366766 + QUAD $0x0a862f80ec4700c8 // .quad 758345818024902856 + QUAD $0xc3b8358109e84f07 // .quad -4343663012265570553 + QUAD $0xcd27bb612758c0fa // .quad -3663753745896259334 + QUAD $0xf4a642e14c6262c8 // .quad -817892746904575288 + QUAD $0x8038d51cb897789c // .quad -9207375118826243940 + QUAD $0x98e7e9cccfbd7dbd // .quad -7428711994456441411 + QUAD $0xe0470a63e6bd56c3 // .quad -2285846861678029117 + QUAD $0xbf21e44003acdd2c // .quad -4674203974643163860 + QUAD $0x1858ccfce06cac74 // .quad 1754377441329851508 + QUAD $0xeeea5d5004981478 // .quad -1231068949876566920 + QUAD $0x0f37801e0c43ebc8 // .quad 1096485900831157192 + QUAD $0x95527a5202df0ccb // .quad -7686947121313936181 + QUAD $0xd30560258f54e6ba // .quad -3241078642388441414 + QUAD $0xbaa718e68396cffd // .quad -4996997883215032323 + QUAD $0x47c6b82ef32a2069 // .quad 5172023733869224041 + QUAD $0xe950df20247c83fd // .quad -1634561335591402499 + QUAD $0x4cdc331d57fa5441 // .quad 5538357842881958977 + QUAD $0x91d28b7416cdd27e // .quad -7939129862385708418 + QUAD $0xe0133fe4adf8e952 // .quad -2300424733252327086 + QUAD $0xb6472e511c81471d // .quad -5312226309554747619 + QUAD $0x58180fddd97723a6 // .quad 6347841120289366950 + QUAD $0xe3d8f9e563a198e5 // .quad -2028596868516046619 + QUAD $0x570f09eaa7ea7648 // .quad 6273243709394548296 + QUAD $0x8e679c2f5e44ff8f // .quad -8185402070463610993 + QUAD $0x2cd2cc6551e513da // .quad 3229868618315797466 + QUAD $0xb201833b35d63f73 // .quad -5620066569652125837 + QUAD $0xf8077f7ea65e58d1 // .quad -574350245532641071 + QUAD $0xde81e40a034bcf4f // .quad -2413397193637769393 + QUAD $0xfb04afaf27faf782 // .quad -358968903457900670 + QUAD $0x8b112e86420f6191 // .quad -8425902273664687727 + QUAD $0x79c5db9af1f9b563 // .quad 8774660907532399971 + QUAD $0xadd57a27d29339f6 // .quad -5920691823653471754 + QUAD $0x18375281ae7822bc // .quad 1744954097560724156 + QUAD $0xd94ad8b1c7380874 // .quad -2789178761139451788 + QUAD $0x8f2293910d0b15b5 // .quad -8132775725879323211 + QUAD $0x87cec76f1c830548 // .quad -8660765753353239224 + QUAD $0xb2eb3875504ddb22 // .quad -5554283638921766110 + QUAD $0xa9c2794ae3a3c69a // .quad -6214271173264161126 + QUAD $0x5fa60692a46151eb // .quad 6892203506629956075 + QUAD $0xd433179d9c8cb841 // .quad -3156152948152813503 + QUAD $0xdbc7c41ba6bcd333 // .quad -2609901835997359309 + QUAD $0x849feec281d7f328 // .quad -8890124620236590296 + QUAD $0x12b9b522906c0800 // .quad 1349308723430688768 + QUAD $0xa5c7ea73224deff3 // .quad -6500969756868349965 + QUAD $0xd768226b34870a00 // .quad -2925050114139026944 + QUAD $0xcf39e50feae16bef // .quad -3514526177658049553 + QUAD $0xe6a1158300d46640 // .quad -1828156321336891840 + QUAD $0x81842f29f2cce375 // .quad -9114107888677362827 + QUAD $0x60495ae3c1097fd0 // .quad 6938176635183661008 + QUAD $0xa1e53af46f801c53 // .quad -6780948842419315629 + QUAD $0x385bb19cb14bdfc4 // .quad 4061034775552188356 + QUAD $0xca5e89b18b602368 // .quad -3864500034596756632 + QUAD $0x46729e03dd9ed7b5 // .quad 5076293469440235445 + QUAD $0xfcf62c1dee382c42 // .quad -218939024818557886 + QUAD $0x6c07a2c26a8346d1 // .quad 7784369436827535057 + QUAD $0x9e19db92b4e31ba9 // .quad -7054365918152680535 + QUAD $0xc7098b7305241885 // .quad -4104596259247744891 + QUAD $0xc5a05277621be293 // .quad -4206271379263462765 + QUAD $0xb8cbee4fc66d1ea7 // .quad -5130745324059681113 + QUAD $0xf70867153aa2db38 // .quad -646153205651940552 + QUAD $0x737f74f1dc043328 // .quad 8322499218531169064 + QUAD $0x9a65406d44a5c903 // .quad -7321374781173544701 + QUAD $0x505f522e53053ff2 // .quad 5791438004736573426 + QUAD $0xc0fe908895cf3b44 // .quad -4540032458039542972 + QUAD $0x647726b9e7c68fef // .quad 7239297505920716783 + QUAD $0xf13e34aabb430a15 // .quad -1063354554122040811 + QUAD $0x5eca783430dc19f5 // .quad 6830403950414141941 + QUAD $0x96c6e0eab509e64d // .quad -7582125623967357363 + QUAD $0xb67d16413d132072 // .quad -5297053117264486286 + QUAD $0xbc789925624c5fe0 // .quad -4865971011531808800 + QUAD $0xe41c5bd18c57e88f // .quad -2009630378153219953 + QUAD $0xeb96bf6ebadf77d8 // .quad -1470777745987373096 + QUAD $0x8e91b962f7b6f159 // .quad -8173548013986844327 + QUAD $0x933e37a534cbaae7 // .quad -7836765118883190041 + QUAD $0x723627bbb5a4adb0 // .quad 8229809056225996208 + QUAD $0xb80dc58e81fe95a1 // .quad -5184270380176599647 + QUAD $0xcec3b1aaa30dd91c // .quad -3547796734999668452 + QUAD $0xe61136f2227e3b09 // .quad -1868651956793361655 + QUAD $0x213a4f0aa5e8a7b1 // .quad 2394313059052595121 + QUAD $0x8fcac257558ee4e6 // .quad -8085436500636932890 + QUAD $0xa988e2cd4f62d19d // .quad -6230480713039031907 + QUAD $0xb3bd72ed2af29e1f // .quad -5495109607368778209 + QUAD $0x93eb1b80a33b8605 // .quad -7788100891298789883 + QUAD $0xe0accfa875af45a7 // .quad -2257200990783584857 + QUAD $0xbc72f130660533c3 // .quad -4867563057061743677 + QUAD $0x8c6c01c9498d8b88 // .quad -8328279646880822392 + QUAD $0xeb8fad7c7f8680b4 // .quad -1472767802899791692 + QUAD $0xaf87023b9bf0ee6a // .quad -5798663540173640086 + QUAD $0xa67398db9f6820e1 // .quad -6452645772052127519 + QUAD $0xdb68c2ca82ed2a05 // .quad -2636643406789662203 + QUAD $0x88083f8943a1148c // .quad -8644589625959967604 + QUAD $0x892179be91d43a43 // .quad -8565431156884620733 + QUAD $0x6a0a4f6b948959b0 // .quad 7641007041259592112 + QUAD $0xab69d82e364948d4 // .quad -6095102927678388012 + QUAD $0x848ce34679abb01c // .quad -8895485272135061476 + QUAD $0xd6444e39c3db9b09 // .quad -3007192641170597111 + QUAD $0xf2d80e0c0c0b4e11 // .quad -947992276657025519 + QUAD $0x85eab0e41a6940e5 // .quad -8797024428372705051 + QUAD $0x6f8e118f0f0e2195 // .quad 8038381691033493909 + QUAD $0xa7655d1d2103911f // .quad -6384594517038493409 + QUAD $0x4b7195f2d2d1a9fb // .quad 5436291095364479483 + QUAD $0xd13eb46469447567 // .quad -3369057127870728857 + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +_POW_TAB: + LONG $0x00000001 // .long 1 + LONG $0x00000003 // .long 3 + LONG $0x00000006 // .long 6 + LONG $0x00000009 // .long 9 + LONG $0x0000000d // .long 13 + LONG $0x00000010 // .long 16 + LONG $0x00000013 // .long 19 + LONG $0x00000017 // .long 23 + LONG $0x0000001a // .long 26 + + // .p2align 2, 0x00 +_MASK_USE_NUMBER: + LONG $0x00000002 // .long 2 + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_Digits: + QUAD $0x3330323031303030; QUAD $0x3730363035303430 // .ascii 16, '0001020304050607' + QUAD $0x3131303139303830; QUAD $0x3531343133313231 // .ascii 16, '0809101112131415' + QUAD $0x3931383137313631; QUAD $0x3332323231323032 // .ascii 16, '1617181920212223' + QUAD $0x3732363235323432; QUAD $0x3133303339323832 // .ascii 16, '2425262728293031' + QUAD $0x3533343333333233; QUAD $0x3933383337333633 // .ascii 16, '3233343536373839' + QUAD $0x3334323431343034; QUAD $0x3734363435343434 // .ascii 16, '4041424344454647' + QUAD $0x3135303539343834; QUAD $0x3535343533353235 // .ascii 16, '4849505152535455' + QUAD $0x3935383537353635; QUAD $0x3336323631363036 // .ascii 16, '5657585960616263' + QUAD $0x3736363635363436; QUAD $0x3137303739363836 // .ascii 16, '6465666768697071' + QUAD $0x3537343733373237; QUAD $0x3937383737373637 // .ascii 16, '7273747576777879' + QUAD $0x3338323831383038; QUAD $0x3738363835383438 // .ascii 16, '8081828384858687' + QUAD $0x3139303939383838; QUAD $0x3539343933393239 // .ascii 16, '8889909192939495' + QUAD $0x3939383937393639 // .ascii 8, '96979899' + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_LB_5d8b2db8: // _pow10_ceil_sig.g + QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721 + QUAD $0x25e8e89c13bb0f7b // .quad 2731688931043774331 + QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807 + QUAD $0x77b191618c54e9ad // .quad 8624834609543440813 + QUAD $0xc795830d75038c1d // .quad -4065198994811024355 + QUAD $0xd59df5b9ef6a2418 // .quad -3054014793352862696 + QUAD $0xf97ae3d0d2446f25 // .quad -469812725086392539 + QUAD $0x4b0573286b44ad1e // .quad 5405853545163697438 + QUAD $0x9becce62836ac577 // .quad -7211161980820077193 + QUAD $0x4ee367f9430aec33 // .quad 5684501474941004851 + QUAD $0xc2e801fb244576d5 // .quad -4402266457597708587 + QUAD $0x229c41f793cda740 // .quad 2493940825248868160 + QUAD $0xf3a20279ed56d48a // .quad -891147053569747830 + QUAD $0x6b43527578c11110 // .quad 7729112049988473104 + QUAD $0x9845418c345644d6 // .quad -7474495936122174250 + QUAD $0x830a13896b78aaaa // .quad -9004363024039368022 + QUAD $0xbe5691ef416bd60c // .quad -4731433901725329908 + QUAD $0x23cc986bc656d554 // .quad 2579604275232953684 + QUAD $0xedec366b11c6cb8f // .quad -1302606358729274481 + QUAD $0x2cbfbe86b7ec8aa9 // .quad 3224505344041192105 + QUAD $0x94b3a202eb1c3f39 // .quad -7731658001846878407 + QUAD $0x7bf7d71432f3d6aa // .quad 8932844867666826922 + QUAD $0xb9e08a83a5e34f07 // .quad -5052886483881210105 + QUAD $0xdaf5ccd93fb0cc54 // .quad -2669001970698630060 + QUAD $0xe858ad248f5c22c9 // .quad -1704422086424124727 + QUAD $0xd1b3400f8f9cff69 // .quad -3336252463373287575 + QUAD $0x91376c36d99995be // .quad -7982792831656159810 + QUAD $0x23100809b9c21fa2 // .quad 2526528228819083170 + QUAD $0xb58547448ffffb2d // .quad -5366805021142811859 + QUAD $0xabd40a0c2832a78b // .quad -6065211750830921845 + QUAD $0xe2e69915b3fff9f9 // .quad -2096820258001126919 + QUAD $0x16c90c8f323f516d // .quad 1641857348316123501 + QUAD $0x8dd01fad907ffc3b // .quad -8228041688891786181 + QUAD $0xae3da7d97f6792e4 // .quad -5891368184943504668 + QUAD $0xb1442798f49ffb4a // .quad -5673366092687344822 + QUAD $0x99cd11cfdf41779d // .quad -7364210231179380835 + QUAD $0xdd95317f31c7fa1d // .quad -2480021597431793123 + QUAD $0x40405643d711d584 // .quad 4629795266307937668 + QUAD $0x8a7d3eef7f1cfc52 // .quad -8467542526035952558 + QUAD $0x482835ea666b2573 // .quad 5199465050656154995 + QUAD $0xad1c8eab5ee43b66 // .quad -5972742139117552794 + QUAD $0xda3243650005eed0 // .quad -2724040723534582064 + QUAD $0xd863b256369d4a40 // .quad -2854241655469553088 + QUAD $0x90bed43e40076a83 // .quad -8016736922845615485 + QUAD $0x873e4f75e2224e68 // .quad -8701430062309552536 + QUAD $0x5a7744a6e804a292 // .quad 6518754469289960082 + QUAD $0xa90de3535aaae202 // .quad -6265101559459552766 + QUAD $0x711515d0a205cb37 // .quad 8148443086612450103 + QUAD $0xd3515c2831559a83 // .quad -3219690930897053053 + QUAD $0x0d5a5b44ca873e04 // .quad 962181821410786820 + QUAD $0x8412d9991ed58091 // .quad -8929835859451740015 + QUAD $0xe858790afe9486c3 // .quad -1704479370831952189 + QUAD $0xa5178fff668ae0b6 // .quad -6550608805887287114 + QUAD $0x626e974dbe39a873 // .quad 7092772823314835571 + QUAD $0xce5d73ff402d98e3 // .quad -3576574988931720989 + QUAD $0xfb0a3d212dc81290 // .quad -357406007711231344 + QUAD $0x80fa687f881c7f8e // .quad -9152888395723407474 + QUAD $0x7ce66634bc9d0b9a // .quad 8999993282035256218 + QUAD $0xa139029f6a239f72 // .quad -6829424476226871438 + QUAD $0x1c1fffc1ebc44e81 // .quad 2026619565689294465 + QUAD $0xc987434744ac874e // .quad -3925094576856201394 + QUAD $0xa327ffb266b56221 // .quad -6690097579743157727 + QUAD $0xfbe9141915d7a922 // .quad -294682202642863838 + QUAD $0x4bf1ff9f0062baa9 // .quad 5472436080603216553 + QUAD $0x9d71ac8fada6c9b5 // .quad -7101705404292871755 + QUAD $0x6f773fc3603db4aa // .quad 8031958568804398250 + QUAD $0xc4ce17b399107c22 // .quad -4265445736938701790 + QUAD $0xcb550fb4384d21d4 // .quad -3795109844276665900 + QUAD $0xf6019da07f549b2b // .quad -720121152745989333 + QUAD $0x7e2a53a146606a49 // .quad 9091170749936331337 + QUAD $0x99c102844f94e0fb // .quad -7367604748107325189 + QUAD $0x2eda7444cbfc426e // .quad 3376138709496513134 + QUAD $0xc0314325637a1939 // .quad -4597819916706768583 + QUAD $0xfa911155fefb5309 // .quad -391512631556746487 + QUAD $0xf03d93eebc589f88 // .quad -1135588877456072824 + QUAD $0x793555ab7eba27cb // .quad 8733981247408842699 + QUAD $0x96267c7535b763b5 // .quad -7627272076051127371 + QUAD $0x4bc1558b2f3458df // .quad 5458738279630526687 + QUAD $0xbbb01b9283253ca2 // .quad -4922404076636521310 + QUAD $0x9eb1aaedfb016f17 // .quad -7011635205744005353 + QUAD $0xea9c227723ee8bcb // .quad -1541319077368263733 + QUAD $0x465e15a979c1cadd // .quad 5070514048102157021 + QUAD $0x92a1958a7675175f // .quad -7880853450996246689 + QUAD $0x0bfacd89ec191eca // .quad 863228270850154186 + QUAD $0xb749faed14125d36 // .quad -5239380795317920458 + QUAD $0xcef980ec671f667c // .quad -3532650679864695172 + QUAD $0xe51c79a85916f484 // .quad -1937539975720012668 + QUAD $0x82b7e12780e7401b // .quad -9027499368258256869 + QUAD $0x8f31cc0937ae58d2 // .quad -8128491512466089774 + QUAD $0xd1b2ecb8b0908811 // .quad -3336344095947716591 + QUAD $0xb2fe3f0b8599ef07 // .quad -5548928372155224313 + QUAD $0x861fa7e6dcb4aa16 // .quad -8782116138362033642 + QUAD $0xdfbdcece67006ac9 // .quad -2324474446766642487 + QUAD $0x67a791e093e1d49b // .quad 7469098900757009563 + QUAD $0x8bd6a141006042bd // .quad -8370325556870233411 + QUAD $0xe0c8bb2c5c6d24e1 // .quad -2249342214667950879 + QUAD $0xaecc49914078536d // .quad -5851220927660403859 + QUAD $0x58fae9f773886e19 // .quad 6411694268519837209 + QUAD $0xda7f5bf590966848 // .quad -2702340141148116920 + QUAD $0xaf39a475506a899f // .quad -5820440219632367201 + QUAD $0x888f99797a5e012d // .quad -8606491615858654931 + QUAD $0x6d8406c952429604 // .quad 7891439908798240260 + QUAD $0xaab37fd7d8f58178 // .quad -6146428501395930760 + QUAD $0xc8e5087ba6d33b84 // .quad -3970758169284363388 + QUAD $0xd5605fcdcf32e1d6 // .quad -3071349608317525546 + QUAD $0xfb1e4a9a90880a65 // .quad -351761693178066331 + QUAD $0x855c3be0a17fcd26 // .quad -8837122532839535322 + QUAD $0x5cf2eea09a550680 // .quad 6697677969404790400 + QUAD $0xa6b34ad8c9dfc06f // .quad -6434717147622031249 + QUAD $0xf42faa48c0ea481f // .quad -851274575098787809 + QUAD $0xd0601d8efc57b08b // .quad -3431710416100151157 + QUAD $0xf13b94daf124da27 // .quad -1064093218873484761 + QUAD $0x823c12795db6ce57 // .quad -9062348037703676329 + QUAD $0x76c53d08d6b70859 // .quad 8558313775058847833 + QUAD $0xa2cb1717b52481ed // .quad -6716249028702207507 + QUAD $0x54768c4b0c64ca6f // .quad 6086206200396171887 + QUAD $0xcb7ddcdda26da268 // .quad -3783625267450371480 + QUAD $0xa9942f5dcf7dfd0a // .quad -6227300304786948854 + QUAD $0xfe5d54150b090b02 // .quad -117845565885576446 + QUAD $0xd3f93b35435d7c4d // .quad -3172439362556298163 + QUAD $0x9efa548d26e5a6e1 // .quad -6991182506319567135 + QUAD $0xc47bc5014a1a6db0 // .quad -4288617610811380304 + QUAD $0xc6b8e9b0709f109a // .quad -4127292114472071014 + QUAD $0x359ab6419ca1091c // .quad 3862600023340550428 + QUAD $0xf867241c8cc6d4c0 // .quad -547429124662700864 + QUAD $0xc30163d203c94b63 // .quad -4395122007679087773 + QUAD $0x9b407691d7fc44f8 // .quad -7259672230555269896 + QUAD $0x79e0de63425dcf1e // .quad 8782263791269039902 + QUAD $0xc21094364dfb5636 // .quad -4462904269766699466 + QUAD $0x985915fc12f542e5 // .quad -7468914334623251739 + QUAD $0xf294b943e17a2bc4 // .quad -966944318780986428 + QUAD $0x3e6f5b7b17b2939e // .quad 4498915137003099038 + QUAD $0x979cf3ca6cec5b5a // .quad -7521869226879198374 + QUAD $0xa705992ceecf9c43 // .quad -6411550076227838909 + QUAD $0xbd8430bd08277231 // .quad -4790650515171610063 + QUAD $0x50c6ff782a838354 // .quad 5820620459997365076 + QUAD $0xece53cec4a314ebd // .quad -1376627125537124675 + QUAD $0xa4f8bf5635246429 // .quad -6559282480285457367 + QUAD $0x940f4613ae5ed136 // .quad -7777920981101784778 + QUAD $0x871b7795e136be9a // .quad -8711237568605798758 + QUAD $0xb913179899f68584 // .quad -5110715207949843068 + QUAD $0x28e2557b59846e40 // .quad 2946011094524915264 + QUAD $0xe757dd7ec07426e5 // .quad -1776707991509915931 + QUAD $0x331aeada2fe589d0 // .quad 3682513868156144080 + QUAD $0x9096ea6f3848984f // .quad -8027971522334779313 + QUAD $0x3ff0d2c85def7622 // .quad 4607414176811284002 + QUAD $0xb4bca50b065abe63 // .quad -5423278384491086237 + QUAD $0x0fed077a756b53aa // .quad 1147581702586717098 + QUAD $0xe1ebce4dc7f16dfb // .quad -2167411962186469893 + QUAD $0xd3e8495912c62895 // .quad -3177208890193991531 + QUAD $0x8d3360f09cf6e4bd // .quad -8272161504007625539 + QUAD $0x64712dd7abbbd95d // .quad 7237616480483531101 + QUAD $0xb080392cc4349dec // .quad -5728515861582144020 + QUAD $0xbd8d794d96aacfb4 // .quad -4788037454677749836 + QUAD $0xdca04777f541c567 // .quad -2548958808550292121 + QUAD $0xecf0d7a0fc5583a1 // .quad -1373360799919799391 + QUAD $0x89e42caaf9491b60 // .quad -8510628282985014432 + QUAD $0xf41686c49db57245 // .quad -858350499949874619 + QUAD $0xac5d37d5b79b6239 // .quad -6026599335303880135 + QUAD $0x311c2875c522ced6 // .quad 3538747893490044630 + QUAD $0xd77485cb25823ac7 // .quad -2921563150702462265 + QUAD $0x7d633293366b828c // .quad 9035120885289943692 + QUAD $0x86a8d39ef77164bc // .quad -8743505996830120772 + QUAD $0xae5dff9c02033198 // .quad -5882264492762254952 + QUAD $0xa8530886b54dbdeb // .quad -6317696477610263061 + QUAD $0xd9f57f830283fdfd // .quad -2741144597525430787 + QUAD $0xd267caa862a12d66 // .quad -3285434578585440922 + QUAD $0xd072df63c324fd7c // .quad -3426430746906788484 + QUAD $0x8380dea93da4bc60 // .quad -8970925639256982432 + QUAD $0x4247cb9e59f71e6e // .quad 4776009810824339054 + QUAD $0xa46116538d0deb78 // .quad -6601971030643840136 + QUAD $0x52d9be85f074e609 // .quad 5970012263530423817 + QUAD $0xcd795be870516656 // .quad -3640777769877412266 + QUAD $0x67902e276c921f8c // .quad 7462515329413029772 + QUAD $0x806bd9714632dff6 // .quad -9193015133814464522 + QUAD $0x00ba1cd8a3db53b7 // .quad 52386062455755703 + QUAD $0xa086cfcd97bf97f3 // .quad -6879582898840692749 + QUAD $0x80e8a40eccd228a5 // .quad -9157889458785081179 + QUAD $0xc8a883c0fdaf7df0 // .quad -3987792605123478032 + QUAD $0x6122cd128006b2ce // .quad 6999382250228200142 + QUAD $0xfad2a4b13d1b5d6c // .quad -373054737976959636 + QUAD $0x796b805720085f82 // .quad 8749227812785250178 + QUAD $0x9cc3a6eec6311a63 // .quad -7150688238876681629 + QUAD $0xcbe3303674053bb1 // .quad -3755104653863994447 + QUAD $0xc3f490aa77bd60fc // .quad -4326674280168464132 + QUAD $0xbedbfc4411068a9d // .quad -4693880817329993059 + QUAD $0xf4f1b4d515acb93b // .quad -796656831783192261 + QUAD $0xee92fb5515482d45 // .quad -1255665003235103419 + QUAD $0x991711052d8bf3c5 // .quad -7415439547505577019 + QUAD $0x751bdd152d4d1c4b // .quad 8438581409832836171 + QUAD $0xbf5cd54678eef0b6 // .quad -4657613415954583370 + QUAD $0xd262d45a78a0635e // .quad -3286831292991118498 + QUAD $0xef340a98172aace4 // .quad -1210330751515841308 + QUAD $0x86fb897116c87c35 // .quad -8720225134666286027 + QUAD $0x9580869f0e7aac0e // .quad -7673985747338482674 + QUAD $0xd45d35e6ae3d4da1 // .quad -3144297699952734815 + QUAD $0xbae0a846d2195712 // .quad -4980796165745715438 + QUAD $0x8974836059cca10a // .quad -8542058143368306422 + QUAD $0xe998d258869facd7 // .quad -1614309188754756393 + QUAD $0x2bd1a438703fc94c // .quad 3157485376071780684 + QUAD $0x91ff83775423cc06 // .quad -7926472270612804602 + QUAD $0x7b6306a34627ddd0 // .quad 8890957387685944784 + QUAD $0xb67f6455292cbf08 // .quad -5296404319838617848 + QUAD $0x1a3bc84c17b1d543 // .quad 1890324697752655171 + QUAD $0xe41f3d6a7377eeca // .quad -2008819381370884406 + QUAD $0x20caba5f1d9e4a94 // .quad 2362905872190818964 + QUAD $0x8e938662882af53e // .quad -8173041140997884610 + QUAD $0x547eb47b7282ee9d // .quad 6088502188546649757 + QUAD $0xb23867fb2a35b28d // .quad -5604615407819967859 + QUAD $0xe99e619a4f23aa44 // .quad -1612744301171463612 + QUAD $0xdec681f9f4c31f31 // .quad -2394083241347571919 + QUAD $0x6405fa00e2ec94d5 // .quad 7207441660390446293 + QUAD $0x8b3c113c38f9f37e // .quad -8413831053483314306 + QUAD $0xde83bc408dd3dd05 // .quad -2412877989897052923 + QUAD $0xae0b158b4738705e // .quad -5905602798426754978 + QUAD $0x9624ab50b148d446 // .quad -7627783505798704058 + QUAD $0xd98ddaee19068c76 // .quad -2770317479606055818 + QUAD $0x3badd624dd9b0958 // .quad 4300328673033783640 + QUAD $0x87f8a8d4cfa417c9 // .quad -8648977452394866743 + QUAD $0xe54ca5d70a80e5d7 // .quad -1923980597781273129 + QUAD $0xa9f6d30a038d1dbc // .quad -6199535797066195524 + QUAD $0x5e9fcf4ccd211f4d // .quad 6818396289628184397 + QUAD $0xd47487cc8470652b // .quad -3137733727905356501 + QUAD $0x7647c32000696720 // .quad 8522995362035230496 + QUAD $0x84c8d4dfd2c63f3b // .quad -8878612607581929669 + QUAD $0x29ecd9f40041e074 // .quad 3021029092058325108 + QUAD $0xa5fb0a17c777cf09 // .quad -6486579741050024183 + QUAD $0xf468107100525891 // .quad -835399653354481519 + QUAD $0xcf79cc9db955c2cc // .quad -3496538657885142324 + QUAD $0x7182148d4066eeb5 // .quad 8179122470161673909 + QUAD $0x81ac1fe293d599bf // .quad -9102865688819295809 + QUAD $0xc6f14cd848405531 // .quad -4111420493003729615 + QUAD $0xa21727db38cb002f // .quad -6766896092596731857 + QUAD $0xb8ada00e5a506a7d // .quad -5139275616254662019 + QUAD $0xca9cf1d206fdc03b // .quad -3846934097318526917 + QUAD $0xa6d90811f0e4851d // .quad -6424094520318327523 + QUAD $0xfd442e4688bd304a // .quad -196981603220770742 + QUAD $0x908f4a166d1da664 // .quad -8030118150397909404 + QUAD $0x9e4a9cec15763e2e // .quad -7040642529654063570 + QUAD $0x9a598e4e043287ff // .quad -7324666853212387329 + QUAD $0xc5dd44271ad3cdba // .quad -4189117143640191558 + QUAD $0x40eff1e1853f29fe // .quad 4679224488766679550 + QUAD $0xf7549530e188c128 // .quad -624710411122851544 + QUAD $0xd12bee59e68ef47d // .quad -3374341425896426371 + QUAD $0x9a94dd3e8cf578b9 // .quad -7307973034592864071 + QUAD $0x82bb74f8301958cf // .quad -9026492418826348337 + QUAD $0xc13a148e3032d6e7 // .quad -4523280274813692185 + QUAD $0xe36a52363c1faf02 // .quad -2059743486678159614 + QUAD $0xf18899b1bc3f8ca1 // .quad -1042414325089727327 + QUAD $0xdc44e6c3cb279ac2 // .quad -2574679358347699518 + QUAD $0x96f5600f15a7b7e5 // .quad -7569037980822161435 + QUAD $0x29ab103a5ef8c0ba // .quad 3002511419460075706 + QUAD $0xbcb2b812db11a5de // .quad -4849611457600313890 + QUAD $0x7415d448f6b6f0e8 // .quad 8364825292752482536 + QUAD $0xebdf661791d60f56 // .quad -1450328303573004458 + QUAD $0x111b495b3464ad22 // .quad 1232659579085827362 + QUAD $0x936b9fcebb25c995 // .quad -7823984217374209643 + QUAD $0xcab10dd900beec35 // .quad -3841273781498745803 + QUAD $0xb84687c269ef3bfb // .quad -5168294253290374149 + QUAD $0x3d5d514f40eea743 // .quad 4421779809981343555 + QUAD $0xe65829b3046b0afa // .quad -1848681798185579782 + QUAD $0x0cb4a5a3112a5113 // .quad 915538744049291539 + QUAD $0x8ff71a0fe2c2e6dc // .quad -8072955151507069220 + QUAD $0x47f0e785eaba72ac // .quad 5183897733458195116 + QUAD $0xb3f4e093db73a093 // .quad -5479507920956448621 + QUAD $0x59ed216765690f57 // .quad 6479872166822743895 + QUAD $0xe0f218b8d25088b8 // .quad -2237698882768172872 + QUAD $0x306869c13ec3532d // .quad 3488154190101041965 + QUAD $0x8c974f7383725573 // .quad -8316090829371189901 + QUAD $0x1e414218c73a13fc // .quad 2180096368813151228 + QUAD $0xafbd2350644eeacf // .quad -5783427518286599473 + QUAD $0xe5d1929ef90898fb // .quad -1886565557410948869 + QUAD $0xdbac6c247d62a583 // .quad -2617598379430861437 + QUAD $0xdf45f746b74abf3a // .quad -2358206946763686086 + QUAD $0x894bc396ce5da772 // .quad -8553528014785370254 + QUAD $0x6b8bba8c328eb784 // .quad 7749492695127472004 + QUAD $0xab9eb47c81f5114f // .quad -6080224000054324913 + QUAD $0x066ea92f3f326565 // .quad 463493832054564197 + QUAD $0xd686619ba27255a2 // .quad -2988593981640518238 + QUAD $0xc80a537b0efefebe // .quad -4032318728359182658 + QUAD $0x8613fd0145877585 // .quad -8785400266166405755 + QUAD $0xbd06742ce95f5f37 // .quad -4826042214438183113 + QUAD $0xa798fc4196e952e7 // .quad -6370064314280619289 + QUAD $0x2c48113823b73705 // .quad 3190819268807046917 + QUAD $0xd17f3b51fca3a7a0 // .quad -3350894374423386208 + QUAD $0xf75a15862ca504c6 // .quad -623161932418579258 + QUAD $0x82ef85133de648c4 // .quad -9011838011655698236 + QUAD $0x9a984d73dbe722fc // .quad -7307005235402693892 + QUAD $0xa3ab66580d5fdaf5 // .quad -6653111496142234891 + QUAD $0xc13e60d0d2e0ebbb // .quad -4522070525825979461 + QUAD $0xcc963fee10b7d1b3 // .quad -3704703351750405709 + QUAD $0x318df905079926a9 // .quad 3570783879572301481 + QUAD $0xffbbcfe994e5c61f // .quad -19193171260619233 + QUAD $0xfdf17746497f7053 // .quad -148206168962011053 + QUAD $0x9fd561f1fd0f9bd3 // .quad -6929524759678968877 + QUAD $0xfeb6ea8bedefa634 // .quad -92628855601256908 + QUAD $0xc7caba6e7c5382c8 // .quad -4050219931171323192 + QUAD $0xfe64a52ee96b8fc1 // .quad -115786069501571135 + QUAD $0xf9bd690a1b68637b // .quad -451088895536766085 + QUAD $0x3dfdce7aa3c673b1 // .quad 4466953431550423985 + QUAD $0x9c1661a651213e2d // .quad -7199459587351560659 + QUAD $0x06bea10ca65c084f // .quad 486002885505321039 + QUAD $0xc31bfa0fe5698db8 // .quad -4387638465762062920 + QUAD $0x486e494fcff30a63 // .quad 5219189625309039203 + QUAD $0xf3e2f893dec3f126 // .quad -872862063775190746 + QUAD $0x5a89dba3c3efccfb // .quad 6523987031636299003 + QUAD $0x986ddb5c6b3a76b7 // .quad -7463067817500576073 + QUAD $0xf89629465a75e01d // .quad -534194123654701027 + QUAD $0xbe89523386091465 // .quad -4717148753448332187 + QUAD $0xf6bbb397f1135824 // .quad -667742654568376284 + QUAD $0xee2ba6c0678b597f // .quad -1284749923383027329 + QUAD $0x746aa07ded582e2d // .quad 8388693718644305453 + QUAD $0x94db483840b717ef // .quad -7720497729755473937 + QUAD $0xa8c2a44eb4571cdd // .quad -6286281471915778851 + QUAD $0xba121a4650e4ddeb // .quad -5038936143766954517 + QUAD $0x92f34d62616ce414 // .quad -7857851839894723564 + QUAD $0xe896a0d7e51e1566 // .quad -1686984161281305242 + QUAD $0x77b020baf9c81d18 // .quad 8624429273841147160 + QUAD $0x915e2486ef32cd60 // .quad -7971894128441897632 + QUAD $0x0ace1474dc1d122f // .quad 778582277723329071 + QUAD $0xb5b5ada8aaff80b8 // .quad -5353181642124984136 + QUAD $0x0d819992132456bb // .quad 973227847154161339 + QUAD $0xe3231912d5bf60e6 // .quad -2079791034228842266 + QUAD $0x10e1fff697ed6c6a // .quad 1216534808942701674 + QUAD $0x8df5efabc5979c8f // .quad -8217398424034108273 + QUAD $0xca8d3ffa1ef463c2 // .quad -3851351762838199358 + QUAD $0xb1736b96b6fd83b3 // .quad -5660062011615247437 + QUAD $0xbd308ff8a6b17cb3 // .quad -4814189703547749197 + QUAD $0xddd0467c64bce4a0 // .quad -2463391496091671392 + QUAD $0xac7cb3f6d05ddbdf // .quad -6017737129434686497 + QUAD $0x8aa22c0dbef60ee4 // .quad -8457148712698376476 + QUAD $0x6bcdf07a423aa96c // .quad 7768129340171790700 + QUAD $0xad4ab7112eb3929d // .quad -5959749872445582691 + QUAD $0x86c16c98d2c953c7 // .quad -8736582398494813241 + QUAD $0xd89d64d57a607744 // .quad -2838001322129590460 + QUAD $0xe871c7bf077ba8b8 // .quad -1697355961263740744 + QUAD $0x87625f056c7c4a8b // .quad -8691279853972075893 + QUAD $0x11471cd764ad4973 // .quad 1244995533423855987 + QUAD $0xa93af6c6c79b5d2d // .quad -6252413799037706963 + QUAD $0xd598e40d3dd89bd0 // .quad -3055441601647567920 + QUAD $0xd389b47879823479 // .quad -3203831230369745799 + QUAD $0x4aff1d108d4ec2c4 // .quad 5404070034795315908 + QUAD $0x843610cb4bf160cb // .quad -8919923546622172981 + QUAD $0xcedf722a585139bb // .quad -3539985255894009413 + QUAD $0xa54394fe1eedb8fe // .quad -6538218414850328322 + QUAD $0xc2974eb4ee658829 // .quad -4424981569867511767 + QUAD $0xce947a3da6a9273e // .quad -3561087000135522498 + QUAD $0x733d226229feea33 // .quad 8303831092947774003 + QUAD $0x811ccc668829b887 // .quad -9143208402725783417 + QUAD $0x0806357d5a3f5260 // .quad 578208414664970848 + QUAD $0xa163ff802a3426a8 // .quad -6817324484979841368 + QUAD $0xca07c2dcb0cf26f8 // .quad -3888925500096174344 + QUAD $0xc9bcff6034c13052 // .quad -3909969587797413806 + QUAD $0xfc89b393dd02f0b6 // .quad -249470856692830026 + QUAD $0xfc2c3f3841f17c67 // .quad -275775966319379353 + QUAD $0xbbac2078d443ace3 // .quad -4923524589293425437 + QUAD $0x9d9ba7832936edc0 // .quad -7089889006590693952 + QUAD $0xd54b944b84aa4c0e // .quad -3077202868308390898 + QUAD $0xc5029163f384a931 // .quad -4250675239810979535 + QUAD $0x0a9e795e65d4df12 // .quad 765182433041899282 + QUAD $0xf64335bcf065d37d // .quad -701658031336336515 + QUAD $0x4d4617b5ff4a16d6 // .quad 5568164059729762006 + QUAD $0x99ea0196163fa42e // .quad -7356065297226292178 + QUAD $0x504bced1bf8e4e46 // .quad 5785945546544795206 + QUAD $0xc06481fb9bcf8d39 // .quad -4583395603105477319 + QUAD $0xe45ec2862f71e1d7 // .quad -1990940103673781801 + QUAD $0xf07da27a82c37088 // .quad -1117558485454458744 + QUAD $0x5d767327bb4e5a4d // .quad 6734696907262548557 + QUAD $0x964e858c91ba2655 // .quad -7616003081050118571 + QUAD $0x3a6a07f8d510f870 // .quad 4209185567039092848 + QUAD $0xbbe226efb628afea // .quad -4908317832885260310 + QUAD $0x890489f70a55368c // .quad -8573576096483297652 + QUAD $0xeadab0aba3b2dbe5 // .quad -1523711272679187483 + QUAD $0x2b45ac74ccea842f // .quad 3118087934678041647 + QUAD $0x92c8ae6b464fc96f // .quad -7869848573065574033 + QUAD $0x3b0b8bc90012929e // .quad 4254647968387469982 + QUAD $0xb77ada0617e3bbcb // .quad -5225624697904579637 + QUAD $0x09ce6ebb40173745 // .quad 706623942056949573 + QUAD $0xe55990879ddcaabd // .quad -1920344853953336643 + QUAD $0xcc420a6a101d0516 // .quad -3728406090856200938 + QUAD $0x8f57fa54c2a9eab6 // .quad -8117744561361917258 + QUAD $0x9fa946824a12232e // .quad -6941939825212513490 + QUAD $0xb32df8e9f3546564 // .quad -5535494683275008668 + QUAD $0x47939822dc96abfa // .quad 5157633273766521850 + QUAD $0xdff9772470297ebd // .quad -2307682335666372931 + QUAD $0x59787e2b93bc56f8 // .quad 6447041592208152312 + QUAD $0x8bfbea76c619ef36 // .quad -8359830487432564938 + QUAD $0x57eb4edb3c55b65b // .quad 6335244004343789147 + QUAD $0xaefae51477a06b03 // .quad -5838102090863318269 + QUAD $0xede622920b6b23f2 // .quad -1304317031425039374 + QUAD $0xdab99e59958885c4 // .quad -2685941595151759932 + QUAD $0xe95fab368e45ecee // .quad -1630396289281299218 + QUAD $0x88b402f7fd75539b // .quad -8596242524610931813 + QUAD $0x11dbcb0218ebb415 // .quad 1286845328412881941 + QUAD $0xaae103b5fcd2a881 // .quad -6133617137336276863 + QUAD $0xd652bdc29f26a11a // .quad -3003129357911285478 + QUAD $0xd59944a37c0752a2 // .quad -3055335403242958174 + QUAD $0x4be76d3346f04960 // .quad 5469460339465668960 + QUAD $0x857fcae62d8493a5 // .quad -8827113654667930715 + QUAD $0x6f70a4400c562ddc // .quad 8030098730593431004 + QUAD $0xa6dfbd9fb8e5b88e // .quad -6422206049907525490 + QUAD $0xcb4ccd500f6bb953 // .quad -3797434642040374957 + QUAD $0xd097ad07a71f26b2 // .quad -3416071543957018958 + QUAD $0x7e2000a41346a7a8 // .quad 9088264752731695016 + QUAD $0x825ecc24c873782f // .quad -9052573742614218705 + QUAD $0x8ed400668c0c28c9 // .quad -8154892584824854327 + QUAD $0xa2f67f2dfa90563b // .quad -6704031159840385477 + QUAD $0x728900802f0f32fb // .quad 8253128342678483707 + QUAD $0xcbb41ef979346bca // .quad -3768352931373093942 + QUAD $0x4f2b40a03ad2ffba // .quad 5704724409920716730 + QUAD $0xfea126b7d78186bc // .quad -98755145788979524 + QUAD $0xe2f610c84987bfa9 // .quad -2092466524453879895 + QUAD $0x9f24b832e6b0f436 // .quad -6979250993759194058 + QUAD $0x0dd9ca7d2df4d7ca // .quad 998051431430019018 + QUAD $0xc6ede63fa05d3143 // .quad -4112377723771604669 + QUAD $0x91503d1c79720dbc // .quad -7975807747567252036 + QUAD $0xf8a95fcf88747d94 // .quad -528786136287117932 + QUAD $0x75a44c6397ce912b // .quad 8476984389250486571 + QUAD $0x9b69dbe1b548ce7c // .quad -7248020362820530564 + QUAD $0xc986afbe3ee11abb // .quad -3925256793573221701 + QUAD $0xc24452da229b021b // .quad -4448339435098275301 + QUAD $0xfbe85badce996169 // .quad -294884973539139223 + QUAD $0xf2d56790ab41c2a2 // .quad -948738275445456222 + QUAD $0xfae27299423fb9c4 // .quad -368606216923924028 + QUAD $0x97c560ba6b0919a5 // .quad -7510490449794491995 + QUAD $0xdccd879fc967d41b // .quad -2536221894791146469 + QUAD $0xbdb6b8e905cb600f // .quad -4776427043815727089 + QUAD $0x5400e987bbc1c921 // .quad 6053094668365842721 + QUAD $0xed246723473e3813 // .quad -1358847786342270957 + QUAD $0x290123e9aab23b69 // .quad 2954682317029915497 + QUAD $0x9436c0760c86e30b // .quad -7766808894105001205 + QUAD $0xf9a0b6720aaf6522 // .quad -459166561069996766 + QUAD $0xb94470938fa89bce // .quad -5096825099203863602 + QUAD $0xf808e40e8d5b3e6a // .quad -573958201337495958 + QUAD $0xe7958cb87392c2c2 // .quad -1759345355577441598 + QUAD $0xb60b1d1230b20e05 // .quad -5329133770099257851 + QUAD $0x90bd77f3483bb9b9 // .quad -8017119874876982855 + QUAD $0xb1c6f22b5e6f48c3 // .quad -5636551615525730109 + QUAD $0xb4ecd5f01a4aa828 // .quad -5409713825168840664 + QUAD $0x1e38aeb6360b1af4 // .quad 2177682517447613172 + QUAD $0xe2280b6c20dd5232 // .quad -2150456263033662926 + QUAD $0x25c6da63c38de1b1 // .quad 2722103146809516465 + QUAD $0x8d590723948a535f // .quad -8261564192037121185 + QUAD $0x579c487e5a38ad0f // .quad 6313000485183335695 + QUAD $0xb0af48ec79ace837 // .quad -5715269221619013577 + QUAD $0x2d835a9df0c6d852 // .quad 3279564588051781714 + QUAD $0xdcdb1b2798182244 // .quad -2532400508596379068 + QUAD $0xf8e431456cf88e66 // .quad -512230283362660762 + QUAD $0x8a08f0f8bf0f156b // .quad -8500279345513818773 + QUAD $0x1b8e9ecb641b5900 // .quad 1985699082112030976 + QUAD $0xac8b2d36eed2dac5 // .quad -6013663163464885563 + QUAD $0xe272467e3d222f40 // .quad -2129562165787349184 + QUAD $0xd7adf884aa879177 // .quad -2905392935903719049 + QUAD $0x5b0ed81dcc6abb10 // .quad 6561419329620589328 + QUAD $0x86ccbb52ea94baea // .quad -8733399612580906262 + QUAD $0x98e947129fc2b4ea // .quad -7428327965055601430 + QUAD $0xa87fea27a539e9a5 // .quad -6305063497298744923 + QUAD $0x3f2398d747b36225 // .quad 4549648098962661925 + QUAD $0xd29fe4b18e88640e // .quad -3269643353196043250 + QUAD $0x8eec7f0d19a03aae // .quad -8147997931578836306 + QUAD $0x83a3eeeef9153e89 // .quad -8961056123388608887 + QUAD $0x1953cf68300424ad // .quad 1825030320404309165 + QUAD $0xa48ceaaab75a8e2b // .quad -6589634135808373205 + QUAD $0x5fa8c3423c052dd8 // .quad 6892973918932774360 + QUAD $0xcdb02555653131b6 // .quad -3625356651333078602 + QUAD $0x3792f412cb06794e // .quad 4004531380238580046 + QUAD $0x808e17555f3ebf11 // .quad -9183376934724255983 + QUAD $0xe2bbd88bbee40bd1 // .quad -2108853905778275375 + QUAD $0xa0b19d2ab70e6ed6 // .quad -6867535149977932074 + QUAD $0x5b6aceaeae9d0ec5 // .quad 6587304654631931589 + QUAD $0xc8de047564d20a8b // .quad -3972732919045027189 + QUAD $0xf245825a5a445276 // .quad -989241218564861322 + QUAD $0xfb158592be068d2e // .quad -354230130378896082 + QUAD $0xeed6e2f0f0d56713 // .quad -1236551523206076653 + QUAD $0x9ced737bb6c4183d // .quad -7138922859127891907 + QUAD $0x55464dd69685606c // .quad 6144684325637283948 + QUAD $0xc428d05aa4751e4c // .quad -4311967555482476980 + QUAD $0xaa97e14c3c26b887 // .quad -6154202648235558777 + QUAD $0xf53304714d9265df // .quad -778273425925708321 + QUAD $0xd53dd99f4b3066a9 // .quad -3081067291867060567 + QUAD $0x993fe2c6d07b7fab // .quad -7403949918844649557 + QUAD $0xe546a8038efe402a // .quad -1925667057416912854 + QUAD $0xbf8fdb78849a5f96 // .quad -4643251380128424042 + QUAD $0xde98520472bdd034 // .quad -2407083821771141068 + QUAD $0xef73d256a5c0f77c // .quad -1192378206733142148 + QUAD $0x963e66858f6d4441 // .quad -7620540795641314239 + QUAD $0x95a8637627989aad // .quad -7662765406849295699 + QUAD $0xdde7001379a44aa9 // .quad -2456994988062127447 + QUAD $0xbb127c53b17ec159 // .quad -4966770740134231719 + QUAD $0x5560c018580d5d53 // .quad 6152128301777116499 + QUAD $0xe9d71b689dde71af // .quad -1596777406740401745 + QUAD $0xaab8f01e6e10b4a7 // .quad -6144897678060768089 + QUAD $0x9226712162ab070d // .quad -7915514906853832947 + QUAD $0xcab3961304ca70e9 // .quad -3840561048787980055 + QUAD $0xb6b00d69bb55c8d1 // .quad -5282707615139903279 + QUAD $0x3d607b97c5fd0d23 // .quad 4422670725869800739 + QUAD $0xe45c10c42a2b3b05 // .quad -1991698500497491195 + QUAD $0x8cb89a7db77c506b // .quad -8306719647944912789 + QUAD $0x8eb98a7a9a5b04e3 // .quad -8162340590452013853 + QUAD $0x77f3608e92adb243 // .quad 8643358275316593219 + QUAD $0xb267ed1940f1c61c // .quad -5591239719637629412 + QUAD $0x55f038b237591ed4 // .quad 6192511825718353620 + QUAD $0xdf01e85f912e37a3 // .quad -2377363631119648861 + QUAD $0x6b6c46dec52f6689 // .quad 7740639782147942025 + QUAD $0x8b61313bbabce2c6 // .quad -8403381297090862394 + QUAD $0x2323ac4b3b3da016 // .quad 2532056854628769814 + QUAD $0xae397d8aa96c1b77 // .quad -5892540602936190089 + QUAD $0xabec975e0a0d081b // .quad -6058300968568813541 + QUAD $0xd9c7dced53c72255 // .quad -2753989735242849707 + QUAD $0x96e7bd358c904a22 // .quad -7572876210711016926 + QUAD $0x881cea14545c7575 // .quad -8638772612167862923 + QUAD $0x7e50d64177da2e55 // .quad 9102010423587778133 + QUAD $0xaa242499697392d2 // .quad -6186779746782440750 + QUAD $0xdde50bd1d5d0b9ea // .quad -2457545025797441046 + QUAD $0xd4ad2dbfc3d07787 // .quad -3121788665050663033 + QUAD $0x955e4ec64b44e865 // .quad -7683617300674189211 + QUAD $0x84ec3c97da624ab4 // .quad -8868646943297746252 + QUAD $0xbd5af13bef0b113f // .quad -4802260812921368257 + QUAD $0xa6274bbdd0fadd61 // .quad -6474122660694794911 + QUAD $0xecb1ad8aeacdd58f // .quad -1391139997724322417 + QUAD $0xcfb11ead453994ba // .quad -3480967307441105734 + QUAD $0x67de18eda5814af3 // .quad 7484447039699372787 + QUAD $0x81ceb32c4b43fcf4 // .quad -9093133594791772940 + QUAD $0x80eacf948770ced8 // .quad -9157278655470055720 + QUAD $0xa2425ff75e14fc31 // .quad -6754730975062328271 + QUAD $0xa1258379a94d028e // .quad -6834912300910181746 + QUAD $0xcad2f7f5359a3b3e // .quad -3831727700400522434 + QUAD $0x096ee45813a04331 // .quad 679731660717048625 + QUAD $0xfd87b5f28300ca0d // .quad -177973607073265139 + QUAD $0x8bca9d6e188853fd // .quad -8373707460958465027 + QUAD $0x9e74d1b791e07e48 // .quad -7028762532061872568 + QUAD $0x775ea264cf55347e // .quad 8601490892183123070 + QUAD $0xc612062576589dda // .quad -4174267146649952806 + QUAD $0x95364afe032a819e // .quad -7694880458480647778 + QUAD $0xf79687aed3eec551 // .quad -606147914885053103 + QUAD $0x3a83ddbd83f52205 // .quad 4216457482181353989 + QUAD $0x9abe14cd44753b52 // .quad -7296371474444240046 + QUAD $0xc4926a9672793543 // .quad -4282243101277735613 + QUAD $0xc16d9a0095928a27 // .quad -4508778324627912153 + QUAD $0x75b7053c0f178294 // .quad 8482254178684994196 + QUAD $0xf1c90080baf72cb1 // .quad -1024286887357502287 + QUAD $0x5324c68b12dd6339 // .quad 5991131704928854841 + QUAD $0x971da05074da7bee // .quad -7557708332239520786 + QUAD $0xd3f6fc16ebca5e04 // .quad -3173071712060547580 + QUAD $0xbce5086492111aea // .quad -4835449396872013078 + QUAD $0x88f4bb1ca6bcf585 // .quad -8578025658503072379 + QUAD $0xec1e4a7db69561a5 // .quad -1432625727662628443 + QUAD $0x2b31e9e3d06c32e6 // .quad 3112525982153323238 + QUAD $0x9392ee8e921d5d07 // .quad -7812920107430224633 + QUAD $0x3aff322e62439fd0 // .quad 4251171748059520976 + QUAD $0xb877aa3236a4b449 // .quad -5154464115860392887 + QUAD $0x09befeb9fad487c3 // .quad 702278666647013315 + QUAD $0xe69594bec44de15b // .quad -1831394126398103205 + QUAD $0x4c2ebe687989a9b4 // .quad 5489534351736154548 + QUAD $0x901d7cf73ab0acd9 // .quad -8062150356639896359 + QUAD $0x0f9d37014bf60a11 // .quad 1125115960621402641 + QUAD $0xb424dc35095cd80f // .quad -5466001927372482545 + QUAD $0x538484c19ef38c95 // .quad 6018080969204141205 + QUAD $0xe12e13424bb40e13 // .quad -2220816390788215277 + QUAD $0x2865a5f206b06fba // .quad 2910915193077788602 + QUAD $0x8cbccc096f5088cb // .quad -8305539271883716405 + QUAD $0xf93f87b7442e45d4 // .quad -486521013540076076 + QUAD $0xafebff0bcb24aafe // .quad -5770238071427257602 + QUAD $0xf78f69a51539d749 // .quad -608151266925095095 + QUAD $0xdbe6fecebdedd5be // .quad -2601111570856684098 + QUAD $0xb573440e5a884d1c // .quad -5371875102083756772 + QUAD $0x89705f4136b4a597 // .quad -8543223759426509417 + QUAD $0x31680a88f8953031 // .quad 3560107088838733873 + QUAD $0xabcc77118461cefc // .quad -6067343680855748868 + QUAD $0xfdc20d2b36ba7c3e // .quad -161552157378970562 + QUAD $0xd6bf94d5e57a42bc // .quad -2972493582642298180 + QUAD $0x3d32907604691b4d // .quad 4409745821703674701 + QUAD $0x8637bd05af6c69b5 // .quad -8775337516792518219 + QUAD $0xa63f9a49c2c1b110 // .quad -6467280898289979120 + QUAD $0xa7c5ac471b478423 // .quad -6357485877563259869 + QUAD $0x0fcf80dc33721d54 // .quad 1139270913992301908 + QUAD $0xd1b71758e219652b // .quad -3335171328526686933 + QUAD $0xd3c36113404ea4a9 // .quad -3187597375937010519 + QUAD $0x83126e978d4fdf3b // .quad -9002011107970261189 + QUAD $0x645a1cac083126ea // .quad 7231123676894144234 + QUAD $0xa3d70a3d70a3d70a // .quad -6640827866535438582 + QUAD $0x3d70a3d70a3d70a4 // .quad 4427218577690292388 + QUAD $0xcccccccccccccccc // .quad -3689348814741910324 + QUAD $0xcccccccccccccccd // .quad -3689348814741910323 + QUAD $0x8000000000000000 // .quad -9223372036854775808 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa000000000000000 // .quad -6917529027641081856 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc800000000000000 // .quad -4035225266123964416 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xfa00000000000000 // .quad -432345564227567616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9c40000000000000 // .quad -7187745005283311616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc350000000000000 // .quad -4372995238176751616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xf424000000000000 // .quad -854558029293551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9896800000000000 // .quad -7451627795949551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xbebc200000000000 // .quad -4702848726509551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xee6b280000000000 // .quad -1266874889709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9502f90000000000 // .quad -7709325833709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xba43b74000000000 // .quad -5024971273709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe8d4a51000000000 // .quad -1669528073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9184e72a00000000 // .quad -7960984073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb5e620f480000000 // .quad -5339544073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe35fa931a0000000 // .quad -2062744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8ac7230489e80000 // .quad -8446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x878678326eac9000 // .quad -8681119073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa968163f0a57b400 // .quad -6239712823709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x84595161401484a0 // .quad -8910000909647051616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x813f3978f8940984 // .quad -9133518327554766460 + QUAD $0x4000000000000000 // .quad 4611686018427387904 + QUAD $0xa18f07d736b90be5 // .quad -6805211891016070171 + QUAD $0x5000000000000000 // .quad 5764607523034234880 + QUAD $0xc9f2c9cd04674ede // .quad -3894828845342699810 + QUAD $0xa400000000000000 // .quad -6629298651489370112 + QUAD $0xfc6f7c4045812296 // .quad -256850038250986858 + QUAD $0x4d00000000000000 // .quad 5548434740920451072 + QUAD $0x9dc5ada82b70b59d // .quad -7078060301547948643 + QUAD $0xf020000000000000 // .quad -1143914305352105984 + QUAD $0xc5371912364ce305 // .quad -4235889358507547899 + QUAD $0x6c28000000000000 // .quad 7793479155164643328 + QUAD $0xf684df56c3e01bc6 // .quad -683175679707046970 + QUAD $0xc732000000000000 // .quad -4093209111326359552 + QUAD $0x9a130b963a6c115c // .quad -7344513827457986212 + QUAD $0x3c7f400000000000 // .quad 4359273333062107136 + QUAD $0xc097ce7bc90715b3 // .quad -4568956265895094861 + QUAD $0x4b9f100000000000 // .quad 5449091666327633920 + QUAD $0xf0bdc21abb48db20 // .quad -1099509313941480672 + QUAD $0x1e86d40000000000 // .quad 2199678564482154496 + QUAD $0x96769950b50d88f4 // .quad -7604722348854507276 + QUAD $0x1314448000000000 // .quad 1374799102801346560 + QUAD $0xbc143fa4e250eb31 // .quad -4894216917640746191 + QUAD $0x17d955a000000000 // .quad 1718498878501683200 + QUAD $0xeb194f8e1ae525fd // .quad -1506085128623544835 + QUAD $0x5dcfab0800000000 // .quad 6759809616554491904 + QUAD $0x92efd1b8d0cf37be // .quad -7858832233030797378 + QUAD $0x5aa1cae500000000 // .quad 6530724019560251392 + QUAD $0xb7abc627050305ad // .quad -5211854272861108819 + QUAD $0xf14a3d9e40000000 // .quad -1059967012404461568 + QUAD $0xe596b7b0c643c719 // .quad -1903131822648998119 + QUAD $0x6d9ccd05d0000000 // .quad 7898413271349198848 + QUAD $0x8f7e32ce7bea5c6f // .quad -8106986416796705681 + QUAD $0xe4820023a2000000 // .quad -1981020733047832576 + QUAD $0xb35dbf821ae4f38b // .quad -5522047002568494197 + QUAD $0xdda2802c8a800000 // .quad -2476275916309790720 + QUAD $0xe0352f62a19e306e // .quad -2290872734783229842 + QUAD $0xd50b2037ad200000 // .quad -3095344895387238400 + QUAD $0x8c213d9da502de45 // .quad -8349324486880600507 + QUAD $0x4526f422cc340000 // .quad 4982938468024057856 + QUAD $0xaf298d050e4395d6 // .quad -5824969590173362730 + QUAD $0x9670b12b7f410000 // .quad -7606384970252091392 + QUAD $0xdaf3f04651d47b4c // .quad -2669525969289315508 + QUAD $0x3c0cdd765f114000 // .quad 4327076842467049472 + QUAD $0x88d8762bf324cd0f // .quad -8585982758446904049 + QUAD $0xa5880a69fb6ac800 // .quad -6518949010312869888 + QUAD $0xab0e93b6efee0053 // .quad -6120792429631242157 + QUAD $0x8eea0d047a457a00 // .quad -8148686262891087360 + QUAD $0xd5d238a4abe98068 // .quad -3039304518611664792 + QUAD $0x72a4904598d6d880 // .quad 8260886245095692416 + QUAD $0x85a36366eb71f041 // .quad -8817094351773372351 + QUAD $0x47a6da2b7f864750 // .quad 5163053903184807760 + QUAD $0xa70c3c40a64e6c51 // .quad -6409681921289327535 + QUAD $0x999090b65f67d924 // .quad -7381240676301154012 + QUAD $0xd0cf4b50cfe20765 // .quad -3400416383184271515 + QUAD $0xfff4b4e3f741cf6d // .quad -3178808521666707 + QUAD $0x82818f1281ed449f // .quad -9042789267131251553 + QUAD $0xbff8f10e7a8921a5 // .quad -4613672773753429595 + QUAD $0xa321f2d7226895c7 // .quad -6691800565486676537 + QUAD $0xaff72d52192b6a0e // .quad -5767090967191786994 + QUAD $0xcbea6f8ceb02bb39 // .quad -3753064688430957767 + QUAD $0x9bf4f8a69f764491 // .quad -7208863708989733743 + QUAD $0xfee50b7025c36a08 // .quad -79644842111309304 + QUAD $0x02f236d04753d5b5 // .quad 212292400617608629 + QUAD $0x9f4f2726179a2245 // .quad -6967307053960650171 + QUAD $0x01d762422c946591 // .quad 132682750386005393 + QUAD $0xc722f0ef9d80aad6 // .quad -4097447799023424810 + QUAD $0x424d3ad2b7b97ef6 // .quad 4777539456409894646 + QUAD $0xf8ebad2b84e0d58b // .quad -510123730351893109 + QUAD $0xd2e0898765a7deb3 // .quad -3251447716342407501 + QUAD $0x9b934c3b330c8577 // .quad -7236356359111015049 + QUAD $0x63cc55f49f88eb30 // .quad 7191217214140771120 + QUAD $0xc2781f49ffcfa6d5 // .quad -4433759430461380907 + QUAD $0x3cbf6b71c76b25fc // .quad 4377335499248575996 + QUAD $0xf316271c7fc3908a // .quad -930513269649338230 + QUAD $0x8bef464e3945ef7b // .quad -8363388681221443717 + QUAD $0x97edd871cfda3a56 // .quad -7499099821171918250 + QUAD $0x97758bf0e3cbb5ad // .quad -7532960934977096275 + QUAD $0xbde94e8e43d0c8ec // .quad -4762188758037509908 + QUAD $0x3d52eeed1cbea318 // .quad 4418856886560793368 + QUAD $0xed63a231d4c4fb27 // .quad -1341049929119499481 + QUAD $0x4ca7aaa863ee4bde // .quad 5523571108200991710 + QUAD $0x945e455f24fb1cf8 // .quad -7755685233340769032 + QUAD $0x8fe8caa93e74ef6b // .quad -8076983103442849941 + QUAD $0xb975d6b6ee39e436 // .quad -5082920523248573386 + QUAD $0xb3e2fd538e122b45 // .quad -5484542860876174523 + QUAD $0xe7d34c64a9c85d44 // .quad -1741964635633328828 + QUAD $0x60dbbca87196b617 // .quad 6979379479186945559 + QUAD $0x90e40fbeea1d3a4a // .quad -8006256924911912374 + QUAD $0xbc8955e946fe31ce // .quad -4861259862362934834 + QUAD $0xb51d13aea4a488dd // .quad -5396135137712502563 + QUAD $0x6babab6398bdbe42 // .quad 7758483227328495170 + QUAD $0xe264589a4dcdab14 // .quad -2133482903713240300 + QUAD $0xc696963c7eed2dd2 // .quad -4136954021121544750 + QUAD $0x8d7eb76070a08aec // .quad -8250955842461857044 + QUAD $0xfc1e1de5cf543ca3 // .quad -279753253987271517 + QUAD $0xb0de65388cc8ada8 // .quad -5702008784649933400 + QUAD $0x3b25a55f43294bcc // .quad 4261994450943298508 + QUAD $0xdd15fe86affad912 // .quad -2515824962385028846 + QUAD $0x49ef0eb713f39ebf // .quad 5327493063679123135 + QUAD $0x8a2dbf142dfcc7ab // .quad -8489919629131724885 + QUAD $0x6e3569326c784338 // .quad 7941369183226839864 + QUAD $0xacb92ed9397bf996 // .quad -6000713517987268202 + QUAD $0x49c2c37f07965405 // .quad 5315025460606161925 + QUAD $0xd7e77a8f87daf7fb // .quad -2889205879056697349 + QUAD $0xdc33745ec97be907 // .quad -2579590211097073401 + QUAD $0x86f0ac99b4e8dafd // .quad -8723282702051517699 + QUAD $0x69a028bb3ded71a4 // .quad 7611128154919104932 + QUAD $0xa8acd7c0222311bc // .quad -6292417359137009220 + QUAD $0xc40832ea0d68ce0d // .quad -4321147861633282547 + QUAD $0xd2d80db02aabd62b // .quad -3253835680493873621 + QUAD $0xf50a3fa490c30191 // .quad -789748808614215279 + QUAD $0x83c7088e1aab65db // .quad -8951176327949752869 + QUAD $0x792667c6da79e0fb // .quad 8729779031470891259 + QUAD $0xa4b8cab1a1563f52 // .quad -6577284391509803182 + QUAD $0x577001b891185939 // .quad 6300537770911226169 + QUAD $0xcde6fd5e09abcf26 // .quad -3609919470959866074 + QUAD $0xed4c0226b55e6f87 // .quad -1347699823215743097 + QUAD $0x80b05e5ac60b6178 // .quad -9173728696990998152 + QUAD $0x544f8158315b05b5 // .quad 6075216638131242421 + QUAD $0xa0dc75f1778e39d6 // .quad -6855474852811359786 + QUAD $0x696361ae3db1c722 // .quad 7594020797664053026 + QUAD $0xc913936dd571c84c // .quad -3957657547586811828 + QUAD $0x03bc3a19cd1e38ea // .quad 269153960225290474 + QUAD $0xfb5878494ace3a5f // .quad -335385916056126881 + QUAD $0x04ab48a04065c724 // .quad 336442450281613092 + QUAD $0x9d174b2dcec0e47b // .quad -7127145225176161157 + QUAD $0x62eb0d64283f9c77 // .quad 7127805559067090039 + QUAD $0xc45d1df942711d9a // .quad -4297245513042813542 + QUAD $0x3ba5d0bd324f8395 // .quad 4298070930406474645 + QUAD $0xf5746577930d6500 // .quad -759870872876129024 + QUAD $0xca8f44ec7ee3647a // .quad -3850783373846682502 + QUAD $0x9968bf6abbe85f20 // .quad -7392448323188662496 + QUAD $0x7e998b13cf4e1ecc // .quad 9122475437414293196 + QUAD $0xbfc2ef456ae276e8 // .quad -4628874385558440216 + QUAD $0x9e3fedd8c321a67f // .quad -7043649776941685121 + QUAD $0xefb3ab16c59b14a2 // .quad -1174406963520662366 + QUAD $0xc5cfe94ef3ea101f // .quad -4192876202749718497 + QUAD $0x95d04aee3b80ece5 // .quad -7651533379841495835 + QUAD $0xbba1f1d158724a13 // .quad -4926390635932268013 + QUAD $0xbb445da9ca61281f // .quad -4952730706374481889 + QUAD $0x2a8a6e45ae8edc98 // .quad 3065383741939440792 + QUAD $0xea1575143cf97226 // .quad -1579227364540714458 + QUAD $0xf52d09d71a3293be // .quad -779956341003086914 + QUAD $0x924d692ca61be758 // .quad -7904546130479028392 + QUAD $0x593c2626705f9c57 // .quad 6430056314514152535 + QUAD $0xb6e0c377cfa2e12e // .quad -5268996644671397586 + QUAD $0x6f8b2fb00c77836d // .quad 8037570393142690669 + QUAD $0xe498f455c38b997a // .quad -1974559787411859078 + QUAD $0x0b6dfb9c0f956448 // .quad 823590954573587528 + QUAD $0x8edf98b59a373fec // .quad -8151628894773493780 + QUAD $0x4724bd4189bd5ead // .quad 5126430365035880109 + QUAD $0xb2977ee300c50fe7 // .quad -5577850100039479321 + QUAD $0x58edec91ec2cb658 // .quad 6408037956294850136 + QUAD $0xdf3d5e9bc0f653e1 // .quad -2360626606621961247 + QUAD $0x2f2967b66737e3ee // .quad 3398361426941174766 + QUAD $0x8b865b215899f46c // .quad -8392920656779807636 + QUAD $0xbd79e0d20082ee75 // .quad -4793553135802847627 + QUAD $0xae67f1e9aec07187 // .quad -5879464802547371641 + QUAD $0xecd8590680a3aa12 // .quad -1380255401326171630 + QUAD $0xda01ee641a708de9 // .quad -2737644984756826647 + QUAD $0xe80e6f4820cc9496 // .quad -1725319251657714538 + QUAD $0x884134fe908658b2 // .quad -8628557143114098510 + QUAD $0x3109058d147fdcde // .quad 3533361486141316318 + QUAD $0xaa51823e34a7eede // .quad -6174010410465235234 + QUAD $0xbd4b46f0599fd416 // .quad -4806670179178130410 + QUAD $0xd4e5e2cdc1d1ea96 // .quad -3105826994654156138 + QUAD $0x6c9e18ac7007c91b // .quad 7826720331309500699 + QUAD $0x850fadc09923329e // .quad -8858670899299929442 + QUAD $0x03e2cf6bc604ddb1 // .quad 280014188641050033 + QUAD $0xa6539930bf6bff45 // .quad -6461652605697523899 + QUAD $0x84db8346b786151d // .quad -8873354301053463267 + QUAD $0xcfe87f7cef46ff16 // .quad -3465379738694516970 + QUAD $0xe612641865679a64 // .quad -1868320839462053276 + QUAD $0x81f14fae158c5f6e // .quad -9083391364325154962 + QUAD $0x4fcb7e8f3f60c07f // .quad 5749828502977298559 + QUAD $0xa26da3999aef7749 // .quad -6742553186979055799 + QUAD $0xe3be5e330f38f09e // .quad -2036086408133152610 + QUAD $0xcb090c8001ab551c // .quad -3816505465296431844 + QUAD $0x5cadf5bfd3072cc6 // .quad 6678264026688335046 + QUAD $0xfdcb4fa002162a63 // .quad -158945813193151901 + QUAD $0x73d9732fc7c8f7f7 // .quad 8347830033360418807 + QUAD $0x9e9f11c4014dda7e // .quad -7016870160886801794 + QUAD $0x2867e7fddcdd9afb // .quad 2911550761636567803 + QUAD $0xc646d63501a1511d // .quad -4159401682681114339 + QUAD $0xb281e1fd541501b9 // .quad -5583933584809066055 + QUAD $0xf7d88bc24209a565 // .quad -587566084924005019 + QUAD $0x1f225a7ca91a4227 // .quad 2243455055843443239 + QUAD $0x9ae757596946075f // .quad -7284757830718584993 + QUAD $0x3375788de9b06959 // .quad 3708002419115845977 + QUAD $0xc1a12d2fc3978937 // .quad -4494261269970843337 + QUAD $0x0052d6b1641c83af // .quad 23317005467419567 + QUAD $0xf209787bb47d6b84 // .quad -1006140569036166268 + QUAD $0xc0678c5dbd23a49b // .quad -4582539761593113445 + QUAD $0x9745eb4d50ce6332 // .quad -7546366883288685774 + QUAD $0xf840b7ba963646e1 // .quad -558244341782001951 + QUAD $0xbd176620a501fbff // .quad -4821272585683469313 + QUAD $0xb650e5a93bc3d899 // .quad -5309491445654890343 + QUAD $0xec5d3fa8ce427aff // .quad -1414904713676948737 + QUAD $0xa3e51f138ab4cebf // .quad -6636864307068612929 + QUAD $0x93ba47c980e98cdf // .quad -7801844473689174817 + QUAD $0xc66f336c36b10138 // .quad -4148040191917883080 + QUAD $0xb8a8d9bbe123f017 // .quad -5140619573684080617 + QUAD $0xb80b0047445d4185 // .quad -5185050239897353851 + QUAD $0xe6d3102ad96cec1d // .quad -1814088448677712867 + QUAD $0xa60dc059157491e6 // .quad -6481312799871692314 + QUAD $0x9043ea1ac7e41392 // .quad -8051334308064652398 + QUAD $0x87c89837ad68db30 // .quad -8662506518347195600 + QUAD $0xb454e4a179dd1877 // .quad -5452481866653427593 + QUAD $0x29babe4598c311fc // .quad 3006924907348169212 + QUAD $0xe16a1dc9d8545e94 // .quad -2203916314889396588 + QUAD $0xf4296dd6fef3d67b // .quad -853029884242176389 + QUAD $0x8ce2529e2734bb1d // .quad -8294976724446954723 + QUAD $0x1899e4a65f58660d // .quad 1772699331562333709 + QUAD $0xb01ae745b101e9e4 // .quad -5757034887131305500 + QUAD $0x5ec05dcff72e7f90 // .quad 6827560182880305040 + QUAD $0xdc21a1171d42645d // .quad -2584607590486743971 + QUAD $0x76707543f4fa1f74 // .quad 8534450228600381300 + QUAD $0x899504ae72497eba // .quad -8532908771695296838 + QUAD $0x6a06494a791c53a9 // .quad 7639874402088932265 + QUAD $0xabfa45da0edbde69 // .quad -6054449946191733143 + QUAD $0x0487db9d17636893 // .quad 326470965756389523 + QUAD $0xd6f8d7509292d603 // .quad -2956376414312278525 + QUAD $0x45a9d2845d3c42b7 // .quad 5019774725622874807 + QUAD $0x865b86925b9bc5c2 // .quad -8765264286586255934 + QUAD $0x0b8a2392ba45a9b3 // .quad 831516194300602803 + QUAD $0xa7f26836f282b732 // .quad -6344894339805432014 + QUAD $0x8e6cac7768d7141f // .quad -8183976793979022305 + QUAD $0xd1ef0244af2364ff // .quad -3319431906329402113 + QUAD $0x3207d795430cd927 // .quad 3605087062808385831 + QUAD $0x8335616aed761f1f // .quad -8992173969096958177 + QUAD $0x7f44e6bd49e807b9 // .quad 9170708441896323001 + QUAD $0xa402b9c5a8d3a6e7 // .quad -6628531442943809817 + QUAD $0x5f16206c9c6209a7 // .quad 6851699533943015847 + QUAD $0xcd036837130890a1 // .quad -3673978285252374367 + QUAD $0x36dba887c37a8c10 // .quad 3952938399001381904 + QUAD $0x802221226be55a64 // .quad -9213765455923815836 + QUAD $0xc2494954da2c978a // .quad -4446942528265218166 + QUAD $0xa02aa96b06deb0fd // .quad -6905520801477381891 + QUAD $0xf2db9baa10b7bd6d // .quad -946992141904134803 + QUAD $0xc83553c5c8965d3d // .quad -4020214983419339459 + QUAD $0x6f92829494e5acc8 // .quad 8039631859474607304 + QUAD $0xfa42a8b73abbf48c // .quad -413582710846786420 + QUAD $0xcb772339ba1f17fa // .quad -3785518230938904582 + QUAD $0x9c69a97284b578d7 // .quad -7176018221920323369 + QUAD $0xff2a760414536efc // .quad -60105885123121412 + QUAD $0xc38413cf25e2d70d // .quad -4358336758973016307 + QUAD $0xfef5138519684abb // .quad -75132356403901765 + QUAD $0xf46518c2ef5b8cd1 // .quad -836234930288882479 + QUAD $0x7eb258665fc25d6a // .quad 9129456591349898602 + QUAD $0x98bf2f79d5993802 // .quad -7440175859071633406 + QUAD $0xef2f773ffbd97a62 // .quad -1211618658047395230 + QUAD $0xbeeefb584aff8603 // .quad -4688533805412153853 + QUAD $0xaafb550ffacfd8fb // .quad -6126209340986631941 + QUAD $0xeeaaba2e5dbf6784 // .quad -1248981238337804412 + QUAD $0x95ba2a53f983cf39 // .quad -7657761676233289927 + QUAD $0x952ab45cfa97a0b2 // .quad -7698142301602209614 + QUAD $0xdd945a747bf26184 // .quad -2480258038432112252 + QUAD $0xba756174393d88df // .quad -5010991858575374113 + QUAD $0x94f971119aeef9e5 // .quad -7712008566467528219 + QUAD $0xe912b9d1478ceb17 // .quad -1652053804791829737 + QUAD $0x7a37cd5601aab85e // .quad 8806733365625141342 + QUAD $0x91abb422ccb812ee // .quad -7950062655635975442 + QUAD $0xac62e055c10ab33b // .quad -6025006692552756421 + QUAD $0xb616a12b7fe617aa // .quad -5325892301117581398 + QUAD $0x577b986b314d600a // .quad 6303799689591218186 + QUAD $0xe39c49765fdf9d94 // .quad -2045679357969588844 + QUAD $0xed5a7e85fda0b80c // .quad -1343622424865753076 + QUAD $0x8e41ade9fbebc27d // .quad -8196078626372074883 + QUAD $0x14588f13be847308 // .quad 1466078993672598280 + QUAD $0xb1d219647ae6b31c // .quad -5633412264537705700 + QUAD $0x596eb2d8ae258fc9 // .quad 6444284760518135753 + QUAD $0xde469fbd99a05fe3 // .quad -2430079312244744221 + QUAD $0x6fca5f8ed9aef3bc // .quad 8055355950647669692 + QUAD $0x8aec23d680043bee // .quad -8436328597794046994 + QUAD $0x25de7bb9480d5855 // .quad 2728754459941099605 + QUAD $0xada72ccc20054ae9 // .quad -5933724728815170839 + QUAD $0xaf561aa79a10ae6b // .quad -5812428961928401301 + QUAD $0xd910f7ff28069da4 // .quad -2805469892591575644 + QUAD $0x1b2ba1518094da05 // .quad 1957835834444274181 + QUAD $0x87aa9aff79042286 // .quad -8670947710510816634 + QUAD $0x90fb44d2f05d0843 // .quad -7999724640327104445 + QUAD $0xa99541bf57452b28 // .quad -6226998619711132888 + QUAD $0x353a1607ac744a54 // .quad 3835402254873283156 + QUAD $0xd3fa922f2d1675f2 // .quad -3172062256211528206 + QUAD $0x42889b8997915ce9 // .quad 4794252818591603945 + QUAD $0x847c9b5d7c2e09b7 // .quad -8900067937773286985 + QUAD $0x69956135febada12 // .quad 7608094030047140370 + QUAD $0xa59bc234db398c25 // .quad -6513398903789220827 + QUAD $0x43fab9837e699096 // .quad 4898431519131537558 + QUAD $0xcf02b2c21207ef2e // .quad -3530062611309138130 + QUAD $0x94f967e45e03f4bc // .quad -7712018656367741764 + QUAD $0x8161afb94b44f57d // .quad -9123818159709293187 + QUAD $0x1d1be0eebac278f6 // .quad 2097517367411243254 + QUAD $0xa1ba1ba79e1632dc // .quad -6793086681209228580 + QUAD $0x6462d92a69731733 // .quad 7233582727691441971 + QUAD $0xca28a291859bbf93 // .quad -3879672333084147821 + QUAD $0x7d7b8f7503cfdcff // .quad 9041978409614302463 + QUAD $0xfcb2cb35e702af78 // .quad -237904397927796872 + QUAD $0x5cda735244c3d43f // .quad 6690786993590490175 + QUAD $0x9defbf01b061adab // .quad -7066219276345954901 + QUAD $0x3a0888136afa64a8 // .quad 4181741870994056360 + QUAD $0xc56baec21c7a1916 // .quad -4221088077005055722 + QUAD $0x088aaa1845b8fdd1 // .quad 615491320315182545 + QUAD $0xf6c69a72a3989f5b // .quad -664674077828931749 + QUAD $0x8aad549e57273d46 // .quad -8454007886460797626 + QUAD $0x9a3c2087a63f6399 // .quad -7332950326284164199 + QUAD $0x36ac54e2f678864c // .quad 3939617107816777292 + QUAD $0xc0cb28a98fcf3c7f // .quad -4554501889427817345 + QUAD $0x84576a1bb416a7de // .quad -8910536670511192098 + QUAD $0xf0fdf2d3f3c30b9f // .quad -1081441343357383777 + QUAD $0x656d44a2a11c51d6 // .quad 7308573235570561494 + QUAD $0x969eb7c47859e743 // .quad -7593429867239446717 + QUAD $0x9f644ae5a4b1b326 // .quad -6961356773836868826 + QUAD $0xbc4665b596706114 // .quad -4880101315621920492 + QUAD $0x873d5d9f0dde1fef // .quad -8701695967296086033 + QUAD $0xeb57ff22fc0c7959 // .quad -1488440626100012711 + QUAD $0xa90cb506d155a7eb // .quad -6265433940692719637 + QUAD $0x9316ff75dd87cbd8 // .quad -7847804418953589800 + QUAD $0x09a7f12442d588f3 // .quad 695789805494438131 + QUAD $0xb7dcbf5354e9bece // .quad -5198069505264599346 + QUAD $0x0c11ed6d538aeb30 // .quad 869737256868047664 + QUAD $0xe5d3ef282a242e81 // .quad -1885900863153361279 + QUAD $0x8f1668c8a86da5fb // .quad -8136200465769716229 + QUAD $0x8fa475791a569d10 // .quad -8096217067111932656 + QUAD $0xf96e017d694487bd // .quad -473439272678684739 + QUAD $0xb38d92d760ec4455 // .quad -5508585315462527915 + QUAD $0x37c981dcc395a9ad // .quad 4019886927579031981 + QUAD $0xe070f78d3927556a // .quad -2274045625900771990 + QUAD $0x85bbe253f47b1418 // .quad -8810199395808373736 + QUAD $0x8c469ab843b89562 // .quad -8338807543829064350 + QUAD $0x93956d7478ccec8f // .quad -7812217631593927537 + QUAD $0xaf58416654a6babb // .quad -5811823411358942533 + QUAD $0x387ac8d1970027b3 // .quad 4069786015789754291 + QUAD $0xdb2e51bfe9d0696a // .quad -2653093245771290262 + QUAD $0x06997b05fcc0319f // .quad 475546501309804959 + QUAD $0x88fcf317f22241e2 // .quad -8575712306248138270 + QUAD $0x441fece3bdf81f04 // .quad 4908902581746016004 + QUAD $0xab3c2fddeeaad25a // .quad -6107954364382784934 + QUAD $0xd527e81cad7626c4 // .quad -3087243809672255804 + QUAD $0xd60b3bd56a5586f1 // .quad -3023256937051093263 + QUAD $0x8a71e223d8d3b075 // .quad -8470740780517707659 + QUAD $0x85c7056562757456 // .quad -8807064613298015146 + QUAD $0xf6872d5667844e4a // .quad -682526969396179382 + QUAD $0xa738c6bebb12d16c // .quad -6397144748195131028 + QUAD $0xb428f8ac016561dc // .quad -5464844730172612132 + QUAD $0xd106f86e69d785c7 // .quad -3384744916816525881 + QUAD $0xe13336d701beba53 // .quad -2219369894288377261 + QUAD $0x82a45b450226b39c // .quad -9032994600651410532 + QUAD $0xecc0024661173474 // .quad -1387106183930235788 + QUAD $0xa34d721642b06084 // .quad -6679557232386875260 + QUAD $0x27f002d7f95d0191 // .quad 2877803288514593169 + QUAD $0xcc20ce9bd35c78a5 // .quad -3737760522056206171 + QUAD $0x31ec038df7b441f5 // .quad 3597254110643241461 + QUAD $0xff290242c83396ce // .quad -60514634142869810 + QUAD $0x7e67047175a15272 // .quad 9108253656731439730 + QUAD $0x9f79a169bd203e41 // .quad -6955350673980375487 + QUAD $0x0f0062c6e984d387 // .quad 1080972517029761927 + QUAD $0xc75809c42c684dd1 // .quad -4082502324048081455 + QUAD $0x52c07b78a3e60869 // .quad 5962901664714590313 + QUAD $0xf92e0c3537826145 // .quad -491441886632713915 + QUAD $0xa7709a56ccdf8a83 // .quad -6381430974388925821 + QUAD $0x9bbcc7a142b17ccb // .quad -7224680206786528053 + QUAD $0x88a66076400bb692 // .quad -8600080377420466542 + QUAD $0xc2abf989935ddbfe // .quad -4419164240055772162 + QUAD $0x6acff893d00ea436 // .quad 7696643601933968438 + QUAD $0xf356f7ebf83552fe // .quad -912269281642327298 + QUAD $0x0583f6b8c4124d44 // .quad 397432465562684740 + QUAD $0x98165af37b2153de // .quad -7487697328667536418 + QUAD $0xc3727a337a8b704b // .quad -4363290727450709941 + QUAD $0xbe1bf1b059e9a8d6 // .quad -4747935642407032618 + QUAD $0x744f18c0592e4c5d // .quad 8380944645968776285 + QUAD $0xeda2ee1c7064130c // .quad -1323233534581402868 + QUAD $0x1162def06f79df74 // .quad 1252808770606194548 + QUAD $0x9485d4d1c63e8be7 // .quad -7744549986754458649 + QUAD $0x8addcb5645ac2ba9 // .quad -8440366555225904215 + QUAD $0xb9a74a0637ce2ee1 // .quad -5069001465015685407 + QUAD $0x6d953e2bd7173693 // .quad 7896285879677171347 + QUAD $0xe8111c87c5c1ba99 // .quad -1724565812842218855 + QUAD $0xc8fa8db6ccdd0438 // .quad -3964700705685699528 + QUAD $0x910ab1d4db9914a0 // .quad -7995382660667468640 + QUAD $0x1d9c9892400a22a3 // .quad 2133748077373825699 + QUAD $0xb54d5e4a127f59c8 // .quad -5382542307406947896 + QUAD $0x2503beb6d00cab4c // .quad 2667185096717282124 + QUAD $0xe2a0b5dc971f303a // .quad -2116491865831296966 + QUAD $0x2e44ae64840fd61e // .quad 3333981370896602654 + QUAD $0x8da471a9de737e24 // .quad -8240336443785642460 + QUAD $0x5ceaecfed289e5d3 // .quad 6695424375237764563 + QUAD $0xb10d8e1456105dad // .quad -5688734536304665171 + QUAD $0x7425a83e872c5f48 // .quad 8369280469047205704 + QUAD $0xdd50f1996b947518 // .quad -2499232151953443560 + QUAD $0xd12f124e28f7771a // .quad -3373457468973156582 + QUAD $0x8a5296ffe33cc92f // .quad -8479549122611984081 + QUAD $0x82bd6b70d99aaa70 // .quad -9025939945749304720 + QUAD $0xace73cbfdc0bfb7b // .quad -5987750384837592197 + QUAD $0x636cc64d1001550c // .quad 7164319141522920716 + QUAD $0xd8210befd30efa5a // .quad -2873001962619602342 + QUAD $0x3c47f7e05401aa4f // .quad 4343712908476262991 + QUAD $0x8714a775e3e95c78 // .quad -8713155254278333320 + QUAD $0x65acfaec34810a72 // .quad 7326506586225052274 + QUAD $0xa8d9d1535ce3b396 // .quad -6279758049420528746 + QUAD $0x7f1839a741a14d0e // .quad 9158133232781315342 + QUAD $0xd31045a8341ca07c // .quad -3238011543348273028 + QUAD $0x1ede48111209a051 // .quad 2224294504121868369 + QUAD $0x83ea2b892091e44d // .quad -8941286242233752499 + QUAD $0x934aed0aab460433 // .quad -7833187971778608077 + QUAD $0xa4e4b66b68b65d60 // .quad -6564921784364802720 + QUAD $0xf81da84d56178540 // .quad -568112927868484288 + QUAD $0xce1de40642e3f4b9 // .quad -3594466212028615495 + QUAD $0x36251260ab9d668f // .quad 3901544858591782543 + QUAD $0x80d2ae83e9ce78f3 // .quad -9164070410158966541 + QUAD $0xc1d72b7c6b42601a // .quad -4479063491021217766 + QUAD $0xa1075a24e4421730 // .quad -6843401994271320272 + QUAD $0xb24cf65b8612f820 // .quad -5598829363776522208 + QUAD $0xc94930ae1d529cfc // .quad -3942566474411762436 + QUAD $0xdee033f26797b628 // .quad -2386850686293264856 + QUAD $0xfb9b7cd9a4a7443c // .quad -316522074587315140 + QUAD $0x169840ef017da3b2 // .quad 1628122660560806834 + QUAD $0x9d412e0806e88aa5 // .quad -7115355324258153819 + QUAD $0x8e1f289560ee864f // .quad -8205795374004271537 + QUAD $0xc491798a08a2ad4e // .quad -4282508136895304370 + QUAD $0xf1a6f2bab92a27e3 // .quad -1033872180650563613 + QUAD $0xf5b5d7ec8acb58a2 // .quad -741449152691742558 + QUAD $0xae10af696774b1dc // .quad -5904026244240592420 + QUAD $0x9991a6f3d6bf1765 // .quad -7380934748073420955 + QUAD $0xacca6da1e0a8ef2a // .quad -5995859411864064214 + QUAD $0xbff610b0cc6edd3f // .quad -4614482416664388289 + QUAD $0x17fd090a58d32af4 // .quad 1728547772024695540 + QUAD $0xeff394dcff8a948e // .quad -1156417002403097458 + QUAD $0xddfc4b4cef07f5b1 // .quad -2451001303396518479 + QUAD $0x95f83d0a1fb69cd9 // .quad -7640289654143017767 + QUAD $0x4abdaf101564f98f // .quad 5385653213018257807 + QUAD $0xbb764c4ca7a4440f // .quad -4938676049251384305 + QUAD $0x9d6d1ad41abe37f2 // .quad -7102991539009341454 + QUAD $0xea53df5fd18d5513 // .quad -1561659043136842477 + QUAD $0x84c86189216dc5ee // .quad -8878739423761676818 + QUAD $0x92746b9be2f8552c // .quad -7893565929601608404 + QUAD $0x32fd3cf5b4e49bb5 // .quad 3674159897003727797 + QUAD $0xb7118682dbb66a77 // .quad -5255271393574622601 + QUAD $0x3fbc8c33221dc2a2 // .quad 4592699871254659746 + QUAD $0xe4d5e82392a40515 // .quad -1957403223540890347 + QUAD $0x0fabaf3feaa5334b // .quad 1129188820640936779 + QUAD $0x8f05b1163ba6832d // .quad -8140906042354138323 + QUAD $0x29cb4d87f2a7400f // .quad 3011586022114279439 + QUAD $0xb2c71d5bca9023f8 // .quad -5564446534515285000 + QUAD $0x743e20e9ef511013 // .quad 8376168546070237203 + QUAD $0xdf78e4b2bd342cf6 // .quad -2343872149716718346 + QUAD $0x914da9246b255417 // .quad -7976533391121755113 + QUAD $0x8bab8eefb6409c1a // .quad -8382449121214030822 + QUAD $0x1ad089b6c2f7548f // .quad 1932195658189984911 + QUAD $0xae9672aba3d0c320 // .quad -5866375383090150624 + QUAD $0xa184ac2473b529b2 // .quad -6808127464117294670 + QUAD $0xda3c0f568cc4f3e8 // .quad -2721283210435300376 + QUAD $0xc9e5d72d90a2741f // .quad -3898473311719230433 + QUAD $0x8865899617fb1871 // .quad -8618331034163144591 + QUAD $0x7e2fa67c7a658893 // .quad 9092669226243950739 + QUAD $0xaa7eebfb9df9de8d // .quad -6161227774276542835 + QUAD $0xddbb901b98feeab8 // .quad -2469221522477225288 + QUAD $0xd51ea6fa85785631 // .quad -3089848699418290639 + QUAD $0x552a74227f3ea566 // .quad 6136845133758244198 + QUAD $0x8533285c936b35de // .quad -8848684464777513506 + QUAD $0xd53a88958f872760 // .quad -3082000819042179232 + QUAD $0xa67ff273b8460356 // .quad -6449169562544503978 + QUAD $0x8a892abaf368f138 // .quad -8464187042230111944 + QUAD $0xd01fef10a657842c // .quad -3449775934753242068 + QUAD $0x2d2b7569b0432d86 // .quad 3254824252494523782 + QUAD $0x8213f56a67f6b29b // .quad -9073638986861858149 + QUAD $0x9c3b29620e29fc74 // .quad -7189106879045698444 + QUAD $0xa298f2c501f45f42 // .quad -6730362715149934782 + QUAD $0x8349f3ba91b47b90 // .quad -8986383598807123056 + QUAD $0xcb3f2f7642717713 // .quad -3801267375510030573 + QUAD $0x241c70a936219a74 // .quad 2602078556773259892 + QUAD $0xfe0efb53d30dd4d7 // .quad -139898200960150313 + QUAD $0xed238cd383aa0111 // .quad -1359087822460813039 + QUAD $0x9ec95d1463e8a506 // .quad -7004965403241175802 + QUAD $0xf4363804324a40ab // .quad -849429889038008149 + QUAD $0xc67bb4597ce2ce48 // .quad -4144520735624081848 + QUAD $0xb143c6053edcd0d6 // .quad -5673473379724898090 + QUAD $0xf81aa16fdc1b81da // .quad -568964901102714406 + QUAD $0xdd94b7868e94050b // .quad -2480155706228734709 + QUAD $0x9b10a4e5e9913128 // .quad -7273132090830278360 + QUAD $0xca7cf2b4191c8327 // .quad -3855940325606653145 + QUAD $0xc1d4ce1f63f57d72 // .quad -4479729095110460046 + QUAD $0xfd1c2f611f63a3f1 // .quad -208239388580928527 + QUAD $0xf24a01a73cf2dccf // .quad -987975350460687153 + QUAD $0xbc633b39673c8ced // .quad -4871985254153548563 + QUAD $0x976e41088617ca01 // .quad -7535013621679011327 + QUAD $0xd5be0503e085d814 // .quad -3044990783845967852 + QUAD $0xbd49d14aa79dbc82 // .quad -4807081008671376254 + QUAD $0x4b2d8644d8a74e19 // .quad 5417133557047315993 + QUAD $0xec9c459d51852ba2 // .quad -1397165242411832414 + QUAD $0xddf8e7d60ed1219f // .quad -2451955090545630817 + QUAD $0x93e1ab8252f33b45 // .quad -7790757304148477115 + QUAD $0xcabb90e5c942b504 // .quad -3838314940804713212 + QUAD $0xb8da1662e7b00a17 // .quad -5126760611758208489 + QUAD $0x3d6a751f3b936244 // .quad 4425478360848884292 + QUAD $0xe7109bfba19c0c9d // .quad -1796764746270372707 + QUAD $0x0cc512670a783ad5 // .quad 920161932633717461 + QUAD $0x906a617d450187e2 // .quad -8040506994060064798 + QUAD $0x27fb2b80668b24c6 // .quad 2880944217109767366 + QUAD $0xb484f9dc9641e9da // .quad -5438947724147693094 + QUAD $0xb1f9f660802dedf7 // .quad -5622191765467566601 + QUAD $0xe1a63853bbd26451 // .quad -2186998636757228463 + QUAD $0x5e7873f8a0396974 // .quad 6807318348447705460 + QUAD $0x8d07e33455637eb2 // .quad -8284403175614349646 + QUAD $0xdb0b487b6423e1e9 // .quad -2662955059861265943 + QUAD $0xb049dc016abc5e5f // .quad -5743817951090549153 + QUAD $0x91ce1a9a3d2cda63 // .quad -7940379843253970333 + QUAD $0xdc5c5301c56b75f7 // .quad -2568086420435798537 + QUAD $0x7641a140cc7810fc // .quad 8521269269642088700 + QUAD $0x89b9b3e11b6329ba // .quad -8522583040413455942 + QUAD $0xa9e904c87fcb0a9e // .quad -6203421752542164322 + QUAD $0xac2820d9623bf429 // .quad -6041542782089432023 + QUAD $0x546345fa9fbdcd45 // .quad 6080780864604458309 + QUAD $0xd732290fbacaf133 // .quad -2940242459184402125 + QUAD $0xa97c177947ad4096 // .quad -6234081974526590826 + QUAD $0x867f59a9d4bed6c0 // .quad -8755180564631333184 + QUAD $0x49ed8eabcccc485e // .quad 5327070802775656542 + QUAD $0xa81f301449ee8c70 // .quad -6332289687361778576 + QUAD $0x5c68f256bfff5a75 // .quad 6658838503469570677 + QUAD $0xd226fc195c6a2f8c // .quad -3303676090774835316 + QUAD $0x73832eec6fff3112 // .quad 8323548129336963346 + QUAD $0x83585d8fd9c25db7 // .quad -8982326584375353929 + QUAD $0xc831fd53c5ff7eac // .quad -4021154456019173716 + QUAD $0xa42e74f3d032f525 // .quad -6616222212041804507 + QUAD $0xba3e7ca8b77f5e56 // .quad -5026443070023967146 + QUAD $0xcd3a1230c43fb26f // .quad -3658591746624867729 + QUAD $0x28ce1bd2e55f35ec // .quad 2940318199324816876 + QUAD $0x80444b5e7aa7cf85 // .quad -9204148869281624187 + QUAD $0x7980d163cf5b81b4 // .quad 8755227902219092404 + QUAD $0xa0555e361951c366 // .quad -6893500068174642330 + QUAD $0xd7e105bcc3326220 // .quad -2891023177508298208 + QUAD $0xc86ab5c39fa63440 // .quad -4005189066790915008 + QUAD $0x8dd9472bf3fefaa8 // .quad -8225464990312760664 + QUAD $0xfa856334878fc150 // .quad -394800315061255856 + QUAD $0xb14f98f6f0feb952 // .quad -5670145219463562926 + QUAD $0x9c935e00d4b9d8d2 // .quad -7164279224554366766 + QUAD $0x6ed1bf9a569f33d4 // .quad 7985374283903742932 + QUAD $0xc3b8358109e84f07 // .quad -4343663012265570553 + QUAD $0x0a862f80ec4700c9 // .quad 758345818024902857 + QUAD $0xf4a642e14c6262c8 // .quad -817892746904575288 + QUAD $0xcd27bb612758c0fb // .quad -3663753745896259333 + QUAD $0x98e7e9cccfbd7dbd // .quad -7428711994456441411 + QUAD $0x8038d51cb897789d // .quad -9207375118826243939 + QUAD $0xbf21e44003acdd2c // .quad -4674203974643163860 + QUAD $0xe0470a63e6bd56c4 // .quad -2285846861678029116 + QUAD $0xeeea5d5004981478 // .quad -1231068949876566920 + QUAD $0x1858ccfce06cac75 // .quad 1754377441329851509 + QUAD $0x95527a5202df0ccb // .quad -7686947121313936181 + QUAD $0x0f37801e0c43ebc9 // .quad 1096485900831157193 + QUAD $0xbaa718e68396cffd // .quad -4996997883215032323 + QUAD $0xd30560258f54e6bb // .quad -3241078642388441413 + QUAD $0xe950df20247c83fd // .quad -1634561335591402499 + QUAD $0x47c6b82ef32a206a // .quad 5172023733869224042 + QUAD $0x91d28b7416cdd27e // .quad -7939129862385708418 + QUAD $0x4cdc331d57fa5442 // .quad 5538357842881958978 + QUAD $0xb6472e511c81471d // .quad -5312226309554747619 + QUAD $0xe0133fe4adf8e953 // .quad -2300424733252327085 + QUAD $0xe3d8f9e563a198e5 // .quad -2028596868516046619 + QUAD $0x58180fddd97723a7 // .quad 6347841120289366951 + QUAD $0x8e679c2f5e44ff8f // .quad -8185402070463610993 + QUAD $0x570f09eaa7ea7649 // .quad 6273243709394548297 + QUAD $0xb201833b35d63f73 // .quad -5620066569652125837 + QUAD $0x2cd2cc6551e513db // .quad 3229868618315797467 + QUAD $0xde81e40a034bcf4f // .quad -2413397193637769393 + QUAD $0xf8077f7ea65e58d2 // .quad -574350245532641070 + QUAD $0x8b112e86420f6191 // .quad -8425902273664687727 + QUAD $0xfb04afaf27faf783 // .quad -358968903457900669 + QUAD $0xadd57a27d29339f6 // .quad -5920691823653471754 + QUAD $0x79c5db9af1f9b564 // .quad 8774660907532399972 + QUAD $0xd94ad8b1c7380874 // .quad -2789178761139451788 + QUAD $0x18375281ae7822bd // .quad 1744954097560724157 + QUAD $0x87cec76f1c830548 // .quad -8660765753353239224 + QUAD $0x8f2293910d0b15b6 // .quad -8132775725879323210 + QUAD $0xa9c2794ae3a3c69a // .quad -6214271173264161126 + QUAD $0xb2eb3875504ddb23 // .quad -5554283638921766109 + QUAD $0xd433179d9c8cb841 // .quad -3156152948152813503 + QUAD $0x5fa60692a46151ec // .quad 6892203506629956076 + QUAD $0x849feec281d7f328 // .quad -8890124620236590296 + QUAD $0xdbc7c41ba6bcd334 // .quad -2609901835997359308 + QUAD $0xa5c7ea73224deff3 // .quad -6500969756868349965 + QUAD $0x12b9b522906c0801 // .quad 1349308723430688769 + QUAD $0xcf39e50feae16bef // .quad -3514526177658049553 + QUAD $0xd768226b34870a01 // .quad -2925050114139026943 + QUAD $0x81842f29f2cce375 // .quad -9114107888677362827 + QUAD $0xe6a1158300d46641 // .quad -1828156321336891839 + QUAD $0xa1e53af46f801c53 // .quad -6780948842419315629 + QUAD $0x60495ae3c1097fd1 // .quad 6938176635183661009 + QUAD $0xca5e89b18b602368 // .quad -3864500034596756632 + QUAD $0x385bb19cb14bdfc5 // .quad 4061034775552188357 + QUAD $0xfcf62c1dee382c42 // .quad -218939024818557886 + QUAD $0x46729e03dd9ed7b6 // .quad 5076293469440235446 + QUAD $0x9e19db92b4e31ba9 // .quad -7054365918152680535 + QUAD $0x6c07a2c26a8346d2 // .quad 7784369436827535058 + + // .p2align 4, 0x00 +_VecShiftShuffles: + QUAD $0x0706050403020100; QUAD $0x0f0e0d0c0b0a0908 // .ascii 16, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' + QUAD $0x0807060504030201; QUAD $0xff0f0e0d0c0b0a09 // .ascii 16, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff' + QUAD $0x0908070605040302; QUAD $0xffff0f0e0d0c0b0a // .ascii 16, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff' + QUAD $0x0a09080706050403; QUAD $0xffffff0f0e0d0c0b // .ascii 16, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff' + QUAD $0x0b0a090807060504; QUAD $0xffffffff0f0e0d0c // .ascii 16, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff' + QUAD $0x0c0b0a0908070605; QUAD $0xffffffffff0f0e0d // .ascii 16, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff' + QUAD $0x0d0c0b0a09080706; QUAD $0xffffffffffff0f0e // .ascii 16, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff' + QUAD $0x0e0d0c0b0a090807; QUAD $0xffffffffffffff0f // .ascii 16, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff' + QUAD $0x0f0e0d0c0b0a0908; QUAD $0xffffffffffffffff // .ascii 16, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff' + + // .p2align 4, 0x00 +__SingleQuoteTab: + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000030303030755c // .asciz 8, '\\u0000\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000031303030755c // .asciz 8, '\\u0001\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000032303030755c // .asciz 8, '\\u0002\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000033303030755c // .asciz 8, '\\u0003\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000034303030755c // .asciz 8, '\\u0004\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000035303030755c // .asciz 8, '\\u0005\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000036303030755c // .asciz 8, '\\u0006\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000037303030755c // .asciz 8, '\\u0007\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000038303030755c // .asciz 8, '\\u0008\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x000000000000745c // .asciz 8, '\\t\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x0000000000006e5c // .asciz 8, '\\n\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000062303030755c // .asciz 8, '\\u000b\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000063303030755c // .asciz 8, '\\u000c\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x000000000000725c // .asciz 8, '\\r\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000065303030755c // .asciz 8, '\\u000e\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000066303030755c // .asciz 8, '\\u000f\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000030313030755c // .asciz 8, '\\u0010\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000031313030755c // .asciz 8, '\\u0011\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000032313030755c // .asciz 8, '\\u0012\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000033313030755c // .asciz 8, '\\u0013\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000034313030755c // .asciz 8, '\\u0014\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000035313030755c // .asciz 8, '\\u0015\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000036313030755c // .asciz 8, '\\u0016\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000037313030755c // .asciz 8, '\\u0017\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000038313030755c // .asciz 8, '\\u0018\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000039313030755c // .asciz 8, '\\u0019\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000061313030755c // .asciz 8, '\\u001a\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000062313030755c // .asciz 8, '\\u001b\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000063313030755c // .asciz 8, '\\u001c\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000064313030755c // .asciz 8, '\\u001d\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000065313030755c // .asciz 8, '\\u001e\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000066313030755c // .asciz 8, '\\u001f\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x000000000000225c // .asciz 8, '\\"\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x0000000000005c5c // .asciz 8, '\\\\\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +__DoubleQuoteTab: + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0030303030755c5c // .asciz 8, '\\\\u0000\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0031303030755c5c // .asciz 8, '\\\\u0001\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0032303030755c5c // .asciz 8, '\\\\u0002\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0033303030755c5c // .asciz 8, '\\\\u0003\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0034303030755c5c // .asciz 8, '\\\\u0004\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0035303030755c5c // .asciz 8, '\\\\u0005\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0036303030755c5c // .asciz 8, '\\\\u0006\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0037303030755c5c // .asciz 8, '\\\\u0007\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0038303030755c5c // .asciz 8, '\\\\u0008\x00' + QUAD $0x0000000000000003 // .quad 3 + QUAD $0x0000000000745c5c // .asciz 8, '\\\\t\x00\x00\x00\x00\x00' + QUAD $0x0000000000000003 // .quad 3 + QUAD $0x00000000006e5c5c // .asciz 8, '\\\\n\x00\x00\x00\x00\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0062303030755c5c // .asciz 8, '\\\\u000b\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0063303030755c5c // .asciz 8, '\\\\u000c\x00' + QUAD $0x0000000000000003 // .quad 3 + QUAD $0x0000000000725c5c // .asciz 8, '\\\\r\x00\x00\x00\x00\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0065303030755c5c // .asciz 8, '\\\\u000e\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0066303030755c5c // .asciz 8, '\\\\u000f\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0030313030755c5c // .asciz 8, '\\\\u0010\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0031313030755c5c // .asciz 8, '\\\\u0011\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0032313030755c5c // .asciz 8, '\\\\u0012\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0033313030755c5c // .asciz 8, '\\\\u0013\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0034313030755c5c // .asciz 8, '\\\\u0014\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0035313030755c5c // .asciz 8, '\\\\u0015\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0036313030755c5c // .asciz 8, '\\\\u0016\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0037313030755c5c // .asciz 8, '\\\\u0017\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0038313030755c5c // .asciz 8, '\\\\u0018\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0039313030755c5c // .asciz 8, '\\\\u0019\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0061313030755c5c // .asciz 8, '\\\\u001a\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0062313030755c5c // .asciz 8, '\\\\u001b\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0063313030755c5c // .asciz 8, '\\\\u001c\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0064313030755c5c // .asciz 8, '\\\\u001d\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0065313030755c5c // .asciz 8, '\\\\u001e\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0066313030755c5c // .asciz 8, '\\\\u001f\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000004 // .quad 4 + QUAD $0x00000000225c5c5c // .asciz 8, '\\\\\\"\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000004 // .quad 4 + QUAD $0x000000005c5c5c5c // .asciz 8, '\\\\\\\\\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +__EscTab: + QUAD $0x0101010101010101; QUAD $0x0101010101010101 // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01' + QUAD $0x0101010101010101; QUAD $0x0101010101010101 // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01' + QUAD $0x0000000000010000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x01 // .ascii 13, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x0000; BYTE $0x00 // .space 3, '\x00\x00\x00' + + // .p2align 4, 0x00 +__UnquoteTab: + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000220000; QUAD $0x2f00000000000000 // .ascii 16, '\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000005c00000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00' + QUAD $0x000c000000080000; QUAD $0x000a000000000000 // .ascii 16, '\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00' + LONG $0x000d0000; WORD $0xff09 // .ascii 6, '\x00\x00\r\x00\t\xff' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; WORD $0x0000 // .space 10, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +__HtmlQuoteTab: + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000036323030755c // .asciz 8, '\\u0026\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000063333030755c // .asciz 8, '\\u003c\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000065333030755c // .asciz 8, '\\u003e\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000038323032755c // .asciz 8, '\\u2028\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000039323032755c // .asciz 8, '\\u2029\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +_LSHIFT_TAB: + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000 // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000001 // .long 1 + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000001 // .long 1 + QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000001 // .long 1 + QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000002 // .long 2 + QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000002 // .long 2 + QUAD $0x0000000035323133; QUAD $0x0000000000000000 // .asciz 16, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000002 // .long 2 + QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000003 // .long 3 + QUAD $0x0000003532313837; QUAD $0x0000000000000000 // .asciz 16, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000003 // .long 3 + QUAD $0x0000353236303933; QUAD $0x0000000000000000 // .asciz 16, '390625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000003 // .long 3 + QUAD $0x0035323133353931; QUAD $0x0000000000000000 // .asciz 16, '1953125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x0035323635363739; QUAD $0x0000000000000000 // .asciz 16, '9765625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x3532313832383834; QUAD $0x0000000000000000 // .asciz 16, '48828125\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x3236303431343432; QUAD $0x0000000000000035 // .asciz 16, '244140625\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x3133303730323231; QUAD $0x0000000000003532 // .asciz 16, '1220703125\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000005 // .long 5 + QUAD $0x3635313533303136; QUAD $0x0000000000003532 // .asciz 16, '6103515625\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000005 // .long 5 + QUAD $0x3837353731353033; QUAD $0x0000000000353231 // .asciz 16, '30517578125\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000005 // .long 5 + QUAD $0x3938373835323531; QUAD $0x0000000035323630 // .asciz 16, '152587890625\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000006 // .long 6 + QUAD $0x3534393339323637; QUAD $0x0000000035323133 // .asciz 16, '762939453125\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000006 // .long 6 + QUAD $0x3237393634313833; QUAD $0x0000003532363536 // .asciz 16, '3814697265625\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000006 // .long 6 + QUAD $0x3638343337303931; QUAD $0x0000353231383233 // .asciz 16, '19073486328125\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3133343736333539; QUAD $0x0000353236303436 // .asciz 16, '95367431640625\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3531373338363734; QUAD $0x0035323133303238 // .asciz 16, '476837158203125\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3735383134383332; QUAD $0x3532363531303139 // .asciz 16, '2384185791015625' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3832393032393131; QUAD $0x3231383730353539 // .asciz 16, '1192092895507812' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000008 // .long 8 + QUAD $0x3434363430363935; QUAD $0x3236303933353737 // .asciz 16, '5960464477539062' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000008 // .long 8 + QUAD $0x3232333230383932; QUAD $0x3133353936373833 // .asciz 16, '2980232238769531' + QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000008 // .long 8 + QUAD $0x3136313130393431; QUAD $0x3536373438333931 // .asciz 16, '1490116119384765' + QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000009 // .long 9 + QUAD $0x3530383530353437; QUAD $0x3832383332393639 // .asciz 16, '7450580596923828' + QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000009 // .long 9 + QUAD $0x3230393235323733; QUAD $0x3431393136343839 // .asciz 16, '3725290298461914' + QUAD $0x0000000035323630; QUAD $0x0000000000000000 // .asciz 16, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000009 // .long 9 + QUAD $0x3135343632363831; QUAD $0x3735393033323934 // .asciz 16, '1862645149230957' + QUAD $0x0000003532313330; QUAD $0x0000000000000000 // .asciz 16, '03125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3735323233313339; QUAD $0x3538373435313634 // .asciz 16, '9313225746154785' + QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3832313636353634; QUAD $0x3239333737303337 // .asciz 16, '4656612873077392' + QUAD $0x0000353231383735; QUAD $0x0000000000000000 // .asciz 16, '578125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3436303338323332; QUAD $0x3639363833353633 // .asciz 16, '2328306436538696' + QUAD $0x0035323630393832; QUAD $0x0000000000000000 // .asciz 16, '2890625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3233353134363131; QUAD $0x3834333936323831 // .asciz 16, '1164153218269348' + QUAD $0x3532313335343431; QUAD $0x0000000000000000 // .asciz 16, '14453125\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000b // .long 11 + QUAD $0x3036363730323835; QUAD $0x3034373634333139 // .asciz 16, '5820766091346740' + QUAD $0x3532363536323237; QUAD $0x0000000000000000 // .asciz 16, '72265625\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000b // .long 11 + QUAD $0x3033383330313932; QUAD $0x3037333337363534 // .asciz 16, '2910383045673370' + QUAD $0x3231383233313633; QUAD $0x0000000000000035 // .asciz 16, '361328125\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000b // .long 11 + QUAD $0x3531393135353431; QUAD $0x3538363633383232 // .asciz 16, '1455191522836685' + QUAD $0x3630343636303831; QUAD $0x0000000000003532 // .asciz 16, '1806640625\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000c // .long 12 + QUAD $0x3637353935373237; QUAD $0x3532343338313431 // .asciz 16, '7275957614183425' + QUAD $0x3133303233333039; QUAD $0x0000000000003532 // .asciz 16, '9033203125\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000c // .long 12 + QUAD $0x3838373937333633; QUAD $0x3231373139303730 // .asciz 16, '3637978807091712' + QUAD $0x3531303636313539; QUAD $0x0000000000353236 // .asciz 16, '95166015625\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000c // .long 12 + QUAD $0x3439383938313831; QUAD $0x3635383534353330 // .asciz 16, '1818989403545856' + QUAD $0x3730303338353734; QUAD $0x0000000035323138 // .asciz 16, '475830078125\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3037343934393039; QUAD $0x3238323932373731 // .asciz 16, '9094947017729282' + QUAD $0x3933303531393733; QUAD $0x0000000035323630 // .asciz 16, '379150390625\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3533373437343534; QUAD $0x3134363436383830 // .asciz 16, '4547473508864641' + QUAD $0x3931353735393831; QUAD $0x0000003532313335 // .asciz 16, '1895751953125\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3736333733373232; QUAD $0x3032333233343435 // .asciz 16, '2273736754432320' + QUAD $0x3935373837343935; QUAD $0x0000353236353637 // .asciz 16, '59478759765625\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3338363836333131; QUAD $0x3036313631323737 // .asciz 16, '1136868377216160' + QUAD $0x3937333933373932; QUAD $0x0035323138323838 // .asciz 16, '297393798828125\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000e // .long 14 + QUAD $0x3831343334383635; QUAD $0x3130383038303638 // .asciz 16, '5684341886080801' + QUAD $0x3939383639363834; QUAD $0x0035323630343134 // .asciz 16, '486968994140625\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000e // .long 14 + QUAD $0x3930373132343832; QUAD $0x3030343034303334 // .asciz 16, '2842170943040400' + QUAD $0x3934343834333437; QUAD $0x3532313330373037 // .asciz 16, '7434844970703125' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000e // .long 14 + QUAD $0x3435383031323431; QUAD $0x3030323032353137 // .asciz 16, '1421085471520200' + QUAD $0x3432323437313733; QUAD $0x3236353135333538 // .asciz 16, '3717422485351562' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000f // .long 15 + QUAD $0x3337323435303137; QUAD $0x3130303130363735 // .asciz 16, '7105427357601001' + QUAD $0x3432313137383538; QUAD $0x3231383735373632 // .asciz 16, '8587112426757812' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000f // .long 15 + QUAD $0x3633313732353533; QUAD $0x3030353030383837 // .asciz 16, '3552713678800500' + QUAD $0x3236353533393239; QUAD $0x3630393837333331 // .asciz 16, '9293556213378906' + QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000f // .long 15 + QUAD $0x3836353336373731; QUAD $0x3035323030343933 // .asciz 16, '1776356839400250' + QUAD $0x3138373736343634; QUAD $0x3335343938363630 // .asciz 16, '4646778106689453' + QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3134383731383838; QUAD $0x3235323130303739 // .asciz 16, '8881784197001252' + QUAD $0x3530393833333233; QUAD $0x3536323734343333 // .asciz 16, '3233890533447265' + QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3032393830343434; QUAD $0x3632363030353839 // .asciz 16, '4440892098500626' + QUAD $0x3235343936313631; QUAD $0x3233363332373636 // .asciz 16, '1616945266723632' + QUAD $0x0000000035323138; QUAD $0x0000000000000000 // .asciz 16, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3036343430323232; QUAD $0x3331333035323934 // .asciz 16, '2220446049250313' + QUAD $0x3632373438303830; QUAD $0x3631383136333333 // .asciz 16, '0808472633361816' + QUAD $0x0000003532363034; QUAD $0x0000000000000000 // .asciz 16, '40625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3033323230313131; QUAD $0x3635313532363432 // .asciz 16, '1110223024625156' + QUAD $0x3336333234303435; QUAD $0x3830393038363631 // .asciz 16, '5404236316680908' + QUAD $0x0000353231333032; QUAD $0x0000000000000000 // .asciz 16, '203125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000011 // .long 17 + QUAD $0x3135313131353535; QUAD $0x3238373532313332 // .asciz 16, '5551115123125782' + QUAD $0x3531383131323037; QUAD $0x3134353430343338 // .asciz 16, '7021181583404541' + QUAD $0x0000353236353130; QUAD $0x0000000000000000 // .asciz 16, '015625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000011 // .long 17 + QUAD $0x3537353535373732; QUAD $0x3139383236353136 // .asciz 16, '2775557561562891' + QUAD $0x3730393530313533; QUAD $0x3037323230373139 // .asciz 16, '3510590791702270' + QUAD $0x0035323138373035; QUAD $0x0000000000000000 // .asciz 16, '5078125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000011 // .long 17 + QUAD $0x3738373737383331; QUAD $0x3534343138373038 // .asciz 16, '1387778780781445' + QUAD $0x3335393235353736; QUAD $0x3533313135383539 // .asciz 16, '6755295395851135' + QUAD $0x3532363039333532; QUAD $0x0000000000000000 // .asciz 16, '25390625\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000012 // .long 18 + QUAD $0x3933393838333936; QUAD $0x3832323730393330 // .asciz 16, '6938893903907228' + QUAD $0x3936373436373733; QUAD $0x3637363535323937 // .asciz 16, '3776476979255676' + QUAD $0x3532313335393632; QUAD $0x0000000000000000 // .asciz 16, '26953125\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000012 // .long 18 + QUAD $0x3936343439363433; QUAD $0x3431363335393135 // .asciz 16, '3469446951953614' + QUAD $0x3438333238383831; QUAD $0x3833383732363938 // .asciz 16, '1888238489627838' + QUAD $0x3236353637343331; QUAD $0x0000000000000035 // .asciz 16, '134765625\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000012 // .long 18 + QUAD $0x3433323734333731; QUAD $0x3730383637393537 // .asciz 16, '1734723475976807' + QUAD $0x3239313134343930; QUAD $0x3931393331383434 // .asciz 16, '0944119244813919' + QUAD $0x3138323833373630; QUAD $0x0000000000003532 // .asciz 16, '0673828125\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000013 // .long 19 + QUAD $0x3337313633373638; QUAD $0x3533303438383937 // .asciz 16, '8673617379884035' + QUAD $0x3236393530323734; QUAD $0x3539353936303432 // .asciz 16, '4720596224069595' + QUAD $0x3630343139363333; QUAD $0x0000000000003532 // .asciz 16, '3369140625\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_P10_TAB: + QUAD $0x3ff0000000000000 // .quad 0x3ff0000000000000 + QUAD $0x4024000000000000 // .quad 0x4024000000000000 + QUAD $0x4059000000000000 // .quad 0x4059000000000000 + QUAD $0x408f400000000000 // .quad 0x408f400000000000 + QUAD $0x40c3880000000000 // .quad 0x40c3880000000000 + QUAD $0x40f86a0000000000 // .quad 0x40f86a0000000000 + QUAD $0x412e848000000000 // .quad 0x412e848000000000 + QUAD $0x416312d000000000 // .quad 0x416312d000000000 + QUAD $0x4197d78400000000 // .quad 0x4197d78400000000 + QUAD $0x41cdcd6500000000 // .quad 0x41cdcd6500000000 + QUAD $0x4202a05f20000000 // .quad 0x4202a05f20000000 + QUAD $0x42374876e8000000 // .quad 0x42374876e8000000 + QUAD $0x426d1a94a2000000 // .quad 0x426d1a94a2000000 + QUAD $0x42a2309ce5400000 // .quad 0x42a2309ce5400000 + QUAD $0x42d6bcc41e900000 // .quad 0x42d6bcc41e900000 + QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000 + QUAD $0x4341c37937e08000 // .quad 0x4341c37937e08000 + QUAD $0x4376345785d8a000 // .quad 0x4376345785d8a000 + QUAD $0x43abc16d674ec800 // .quad 0x43abc16d674ec800 + QUAD $0x43e158e460913d00 // .quad 0x43e158e460913d00 + QUAD $0x4415af1d78b58c40 // .quad 0x4415af1d78b58c40 + QUAD $0x444b1ae4d6e2ef50 // .quad 0x444b1ae4d6e2ef50 + QUAD $0x4480f0cf064dd592 // .quad 0x4480f0cf064dd592 + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_LB_85cdfac5: // _pow10_ceil_sig_f32.g + QUAD $0x81ceb32c4b43fcf5 // .quad -9093133594791772939 + QUAD $0xa2425ff75e14fc32 // .quad -6754730975062328270 + QUAD $0xcad2f7f5359a3b3f // .quad -3831727700400522433 + QUAD $0xfd87b5f28300ca0e // .quad -177973607073265138 + QUAD $0x9e74d1b791e07e49 // .quad -7028762532061872567 + QUAD $0xc612062576589ddb // .quad -4174267146649952805 + QUAD $0xf79687aed3eec552 // .quad -606147914885053102 + QUAD $0x9abe14cd44753b53 // .quad -7296371474444240045 + QUAD $0xc16d9a0095928a28 // .quad -4508778324627912152 + QUAD $0xf1c90080baf72cb2 // .quad -1024286887357502286 + QUAD $0x971da05074da7bef // .quad -7557708332239520785 + QUAD $0xbce5086492111aeb // .quad -4835449396872013077 + QUAD $0xec1e4a7db69561a6 // .quad -1432625727662628442 + QUAD $0x9392ee8e921d5d08 // .quad -7812920107430224632 + QUAD $0xb877aa3236a4b44a // .quad -5154464115860392886 + QUAD $0xe69594bec44de15c // .quad -1831394126398103204 + QUAD $0x901d7cf73ab0acda // .quad -8062150356639896358 + QUAD $0xb424dc35095cd810 // .quad -5466001927372482544 + QUAD $0xe12e13424bb40e14 // .quad -2220816390788215276 + QUAD $0x8cbccc096f5088cc // .quad -8305539271883716404 + QUAD $0xafebff0bcb24aaff // .quad -5770238071427257601 + QUAD $0xdbe6fecebdedd5bf // .quad -2601111570856684097 + QUAD $0x89705f4136b4a598 // .quad -8543223759426509416 + QUAD $0xabcc77118461cefd // .quad -6067343680855748867 + QUAD $0xd6bf94d5e57a42bd // .quad -2972493582642298179 + QUAD $0x8637bd05af6c69b6 // .quad -8775337516792518218 + QUAD $0xa7c5ac471b478424 // .quad -6357485877563259868 + QUAD $0xd1b71758e219652c // .quad -3335171328526686932 + QUAD $0x83126e978d4fdf3c // .quad -9002011107970261188 + QUAD $0xa3d70a3d70a3d70b // .quad -6640827866535438581 + QUAD $0xcccccccccccccccd // .quad -3689348814741910323 + QUAD $0x8000000000000000 // .quad -9223372036854775808 + QUAD $0xa000000000000000 // .quad -6917529027641081856 + QUAD $0xc800000000000000 // .quad -4035225266123964416 + QUAD $0xfa00000000000000 // .quad -432345564227567616 + QUAD $0x9c40000000000000 // .quad -7187745005283311616 + QUAD $0xc350000000000000 // .quad -4372995238176751616 + QUAD $0xf424000000000000 // .quad -854558029293551616 + QUAD $0x9896800000000000 // .quad -7451627795949551616 + QUAD $0xbebc200000000000 // .quad -4702848726509551616 + QUAD $0xee6b280000000000 // .quad -1266874889709551616 + QUAD $0x9502f90000000000 // .quad -7709325833709551616 + QUAD $0xba43b74000000000 // .quad -5024971273709551616 + QUAD $0xe8d4a51000000000 // .quad -1669528073709551616 + QUAD $0x9184e72a00000000 // .quad -7960984073709551616 + QUAD $0xb5e620f480000000 // .quad -5339544073709551616 + QUAD $0xe35fa931a0000000 // .quad -2062744073709551616 + QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616 + QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616 + QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616 + QUAD $0x8ac7230489e80000 // .quad -8446744073709551616 + QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616 + QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616 + QUAD $0x878678326eac9000 // .quad -8681119073709551616 + QUAD $0xa968163f0a57b400 // .quad -6239712823709551616 + QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616 + QUAD $0x84595161401484a0 // .quad -8910000909647051616 + QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616 + QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366 + QUAD $0x813f3978f8940985 // .quad -9133518327554766459 + QUAD $0xa18f07d736b90be6 // .quad -6805211891016070170 + QUAD $0xc9f2c9cd04674edf // .quad -3894828845342699809 + QUAD $0xfc6f7c4045812297 // .quad -256850038250986857 + QUAD $0x9dc5ada82b70b59e // .quad -7078060301547948642 + QUAD $0xc5371912364ce306 // .quad -4235889358507547898 + QUAD $0xf684df56c3e01bc7 // .quad -683175679707046969 + QUAD $0x9a130b963a6c115d // .quad -7344513827457986211 + QUAD $0xc097ce7bc90715b4 // .quad -4568956265895094860 + QUAD $0xf0bdc21abb48db21 // .quad -1099509313941480671 + QUAD $0x96769950b50d88f5 // .quad -7604722348854507275 + QUAD $0xbc143fa4e250eb32 // .quad -4894216917640746190 + QUAD $0xeb194f8e1ae525fe // .quad -1506085128623544834 + QUAD $0x92efd1b8d0cf37bf // .quad -7858832233030797377 + QUAD $0xb7abc627050305ae // .quad -5211854272861108818 + QUAD $0xe596b7b0c643c71a // .quad -1903131822648998118 + QUAD $0x8f7e32ce7bea5c70 // .quad -8106986416796705680 + QUAD $0xb35dbf821ae4f38c // .quad -5522047002568494196 + +TEXT ·__f32toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -56(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_f32toa: + MOVQ out+0(FP), DI + MOVSD val+8(FP), X0 + CALL ·__native_entry__+35216(SB) // _f32toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__f64toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -80(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_f64toa: + MOVQ out+0(FP), DI + MOVSD val+8(FP), X0 + CALL ·__native_entry__+752(SB) // _f64toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -320(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_get_by_path: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ path+16(FP), DX + CALL ·__native_entry__+30384(SB) // _get_by_path + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__html_escape(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -72(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_html_escape: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ dp+16(FP), DX + MOVQ dn+24(FP), CX + CALL ·__native_entry__+11712(SB) // _html_escape + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__i64toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -16(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_i64toa: + MOVQ out+0(FP), DI + MOVQ val+8(FP), SI + CALL ·__native_entry__+4368(SB) // _i64toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__lspace(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -8(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_lspace: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ off+16(FP), DX + CALL ·__native_entry__+224(SB) // _lspace + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__quote(SB), NOSPLIT | NOFRAME, $0 - 48 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -72(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_quote: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ dp+16(FP), DX + MOVQ dn+24(FP), CX + MOVQ flags+32(FP), R8 + CALL ·__native_entry__+6160(SB) // _quote + MOVQ AX, ret+40(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_array(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -120(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_array: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + MOVQ flags+24(FP), CX + CALL ·__native_entry__+22864(SB) // _skip_array + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_number(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -80(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_number: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + CALL ·__native_entry__+26928(SB) // _skip_number + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_object(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -120(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_object: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + MOVQ flags+24(FP), CX + CALL ·__native_entry__+24864(SB) // _skip_object + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_one(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -120(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_one: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + MOVQ flags+24(FP), CX + CALL ·__native_entry__+27088(SB) // _skip_one + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_one_fast(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -216(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_one_fast: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + CALL ·__native_entry__+27504(SB) // _skip_one_fast + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__u64toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -8(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_u64toa: + MOVQ out+0(FP), DI + MOVQ val+8(FP), SI + CALL ·__native_entry__+4640(SB) // _u64toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__unquote(SB), NOSPLIT | NOFRAME, $0 - 48 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_unquote: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ dp+16(FP), DX + MOVQ ep+24(FP), CX + MOVQ flags+32(FP), R8 + CALL ·__native_entry__+8960(SB) // _unquote + MOVQ AX, ret+40(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__validate_one(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -120(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_validate_one: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + CALL ·__native_entry__+27152(SB) // _validate_one + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__validate_utf8(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -48(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_validate_utf8: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + CALL ·__native_entry__+31552(SB) // _validate_utf8 + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__validate_utf8_fast(SB), NOSPLIT | NOFRAME, $0 - 16 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -200(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_validate_utf8_fast: + MOVQ s+0(FP), DI + CALL ·__native_entry__+32496(SB) // _validate_utf8_fast + MOVQ AX, ret+8(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__value(SB), NOSPLIT | NOFRAME, $0 - 48 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -368(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_value: + MOVQ s+0(FP), DI + MOVQ n+8(FP), SI + MOVQ p+16(FP), DX + MOVQ v+24(FP), CX + MOVQ flags+32(FP), R8 + CALL ·__native_entry__+16816(SB) // _value + MOVQ AX, ret+40(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vnumber(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -280(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vnumber: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + LEAQ ·__native_entry__+20608(SB), AX // _vnumber + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vsigned(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -16(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vsigned: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + LEAQ ·__native_entry__+22144(SB), AX // _vsigned + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vstring(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -104(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vstring: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + MOVQ flags+24(FP), CX + LEAQ ·__native_entry__+19312(SB), AX // _vstring + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vunsigned(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -24(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vunsigned: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + LEAQ ·__native_entry__+22496(SB), AX // _vunsigned + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_export_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_export_amd64.go new file mode 100644 index 000000000..8adf5e91f --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_export_amd64.go @@ -0,0 +1,49 @@ +// 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 avx2 + +var ( + S_f64toa = _subr__f64toa + S_f32toa = _subr__f32toa + S_i64toa = _subr__i64toa + S_u64toa = _subr__u64toa + S_lspace = _subr__lspace +) + +var ( + S_quote = _subr__quote + S_unquote = _subr__unquote +) + +var ( + S_value = _subr__value + S_vstring = _subr__vstring + S_vnumber = _subr__vnumber + S_vsigned = _subr__vsigned + S_vunsigned = _subr__vunsigned +) + +var ( + S_skip_one = _subr__skip_one + S_skip_one_fast = _subr__skip_one_fast + S_skip_array = _subr__skip_array + S_skip_object = _subr__skip_object + S_skip_number = _subr__skip_number + S_get_by_path = _subr__get_by_path +) diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go new file mode 100644 index 000000000..bd8014e58 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go @@ -0,0 +1,109 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package avx2 + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __native_entry__() uintptr + +var ( + _subr__f32toa = __native_entry__() + 35216 + _subr__f64toa = __native_entry__() + 752 + _subr__get_by_path = __native_entry__() + 30384 + _subr__html_escape = __native_entry__() + 11712 + _subr__i64toa = __native_entry__() + 4368 + _subr__lspace = __native_entry__() + 224 + _subr__quote = __native_entry__() + 6160 + _subr__skip_array = __native_entry__() + 22864 + _subr__skip_number = __native_entry__() + 26928 + _subr__skip_object = __native_entry__() + 24864 + _subr__skip_one = __native_entry__() + 27088 + _subr__skip_one_fast = __native_entry__() + 27504 + _subr__u64toa = __native_entry__() + 4640 + _subr__unquote = __native_entry__() + 8960 + _subr__validate_one = __native_entry__() + 27152 + _subr__validate_utf8 = __native_entry__() + 31552 + _subr__validate_utf8_fast = __native_entry__() + 32496 + _subr__value = __native_entry__() + 16816 + _subr__vnumber = __native_entry__() + 20608 + _subr__vsigned = __native_entry__() + 22144 + _subr__vstring = __native_entry__() + 19312 + _subr__vunsigned = __native_entry__() + 22496 +) + +const ( + _stack__f32toa = 56 + _stack__f64toa = 80 + _stack__get_by_path = 320 + _stack__html_escape = 72 + _stack__i64toa = 16 + _stack__lspace = 8 + _stack__quote = 72 + _stack__skip_array = 120 + _stack__skip_number = 80 + _stack__skip_object = 120 + _stack__skip_one = 120 + _stack__skip_one_fast = 216 + _stack__u64toa = 8 + _stack__unquote = 128 + _stack__validate_one = 120 + _stack__validate_utf8 = 48 + _stack__validate_utf8_fast = 200 + _stack__value = 368 + _stack__vnumber = 280 + _stack__vsigned = 16 + _stack__vstring = 104 + _stack__vunsigned = 24 +) + +var ( + _ = _subr__f32toa + _ = _subr__f64toa + _ = _subr__get_by_path + _ = _subr__html_escape + _ = _subr__i64toa + _ = _subr__lspace + _ = _subr__quote + _ = _subr__skip_array + _ = _subr__skip_number + _ = _subr__skip_object + _ = _subr__skip_one + _ = _subr__skip_one_fast + _ = _subr__u64toa + _ = _subr__unquote + _ = _subr__validate_one + _ = _subr__validate_utf8 + _ = _subr__validate_utf8_fast + _ = _subr__value + _ = _subr__vnumber + _ = _subr__vsigned + _ = _subr__vstring + _ = _subr__vunsigned +) + +const ( + _ = _stack__f32toa + _ = _stack__f64toa + _ = _stack__get_by_path + _ = _stack__html_escape + _ = _stack__i64toa + _ = _stack__lspace + _ = _stack__quote + _ = _stack__skip_array + _ = _stack__skip_number + _ = _stack__skip_object + _ = _stack__skip_one + _ = _stack__skip_one_fast + _ = _stack__u64toa + _ = _stack__unquote + _ = _stack__validate_one + _ = _stack__validate_utf8 + _ = _stack__validate_utf8_fast + _ = _stack__value + _ = _stack__vnumber + _ = _stack__vsigned + _ = _stack__vstring + _ = _stack__vunsigned +) diff --git a/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go new file mode 100644 index 000000000..6aba0051f --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go @@ -0,0 +1,202 @@ +/* + * 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 native + +import ( + `unsafe` + + `github.com/bytedance/sonic/internal/cpu` + `github.com/bytedance/sonic/internal/native/avx` + `github.com/bytedance/sonic/internal/native/avx2` + `github.com/bytedance/sonic/internal/native/sse` + `github.com/bytedance/sonic/internal/native/types` +) + +const ( + MaxFrameSize uintptr = 400 + BufPaddingSize int = 64 +) + +var ( + S_f64toa uintptr + S_f32toa uintptr + S_i64toa uintptr + S_u64toa uintptr + S_lspace uintptr +) + +var ( + S_quote uintptr + S_unquote uintptr +) + +var ( + S_value uintptr + S_vstring uintptr + S_vnumber uintptr + S_vsigned uintptr + S_vunsigned uintptr +) + +var ( + S_skip_one uintptr + S_skip_one_fast uintptr + S_get_by_path uintptr + S_skip_array uintptr + S_skip_object uintptr + S_skip_number uintptr +) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func Quote(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) int + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func Unquote(s unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) int + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func HTMLEscape(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) int + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func Value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) int + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func SkipOne(s *string, p *int, m *types.StateMachine, flags uint64) int + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func SkipOneFast(s *string, p *int) int + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func GetByPath(s *string, p *int, path *[]interface{}) int + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func ValidateOne(s *string, p *int, m *types.StateMachine) int + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func I64toa(out *byte, val int64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func U64toa(out *byte, val uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func F64toa(out *byte, val float64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func ValidateUTF8(s *string, p *int, m *types.StateMachine) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func ValidateUTF8Fast(s *string) (ret int) + +func useAVX() { + S_f64toa = avx.S_f64toa + S_f32toa = avx.S_f32toa + S_i64toa = avx.S_i64toa + S_u64toa = avx.S_u64toa + S_lspace = avx.S_lspace + S_quote = avx.S_quote + S_unquote = avx.S_unquote + S_value = avx.S_value + S_vstring = avx.S_vstring + S_vnumber = avx.S_vnumber + S_vsigned = avx.S_vsigned + S_vunsigned = avx.S_vunsigned + S_skip_one = avx.S_skip_one + S_skip_one_fast = avx.S_skip_one_fast + S_skip_array = avx.S_skip_array + S_skip_object = avx.S_skip_object + S_skip_number = avx.S_skip_number + S_get_by_path = avx.S_get_by_path +} + +func useAVX2() { + S_f64toa = avx2.S_f64toa + S_f32toa = avx2.S_f32toa + S_i64toa = avx2.S_i64toa + S_u64toa = avx2.S_u64toa + S_lspace = avx2.S_lspace + S_quote = avx2.S_quote + S_unquote = avx2.S_unquote + S_value = avx2.S_value + S_vstring = avx2.S_vstring + S_vnumber = avx2.S_vnumber + S_vsigned = avx2.S_vsigned + S_vunsigned = avx2.S_vunsigned + S_skip_one = avx2.S_skip_one + S_skip_one_fast = avx2.S_skip_one_fast + S_skip_array = avx2.S_skip_array + S_skip_object = avx2.S_skip_object + S_skip_number = avx2.S_skip_number + S_get_by_path = avx2.S_get_by_path +} + +func useSSE() { + S_f64toa = sse.S_f64toa + S_f32toa = sse.S_f32toa + S_i64toa = sse.S_i64toa + S_u64toa = sse.S_u64toa + S_lspace = sse.S_lspace + S_quote = sse.S_quote + S_unquote = sse.S_unquote + S_value = sse.S_value + S_vstring = sse.S_vstring + S_vnumber = sse.S_vnumber + S_vsigned = sse.S_vsigned + S_vunsigned = sse.S_vunsigned + S_skip_one = sse.S_skip_one + S_skip_one_fast = sse.S_skip_one_fast + S_skip_array = sse.S_skip_array + S_skip_object = sse.S_skip_object + S_skip_number = sse.S_skip_number + S_get_by_path = sse.S_get_by_path +} + +func init() { + if cpu.HasAVX2 { + useAVX2() + } else if cpu.HasAVX { + useAVX() + } else if cpu.HasSSE { + useSSE() + } else { + panic("Unsupported CPU, maybe it's too old to run Sonic.") + } +} diff --git a/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.s new file mode 100644 index 000000000..858fe0212 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.s @@ -0,0 +1,137 @@ +// +// 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 ·Quote(SB), NOSPLIT, $0 - 48 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__quote(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__quote(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__quote(SB) + +TEXT ·Unquote(SB), NOSPLIT, $0 - 48 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__unquote(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__unquote(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__unquote(SB) + +TEXT ·HTMLEscape(SB), NOSPLIT, $0 - 40 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__html_escape(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__html_escape(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__html_escape(SB) + +TEXT ·Value(SB), NOSPLIT, $0 - 48 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__value(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__value(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__value(SB) + +TEXT ·SkipOne(SB), NOSPLIT, $0 - 40 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__skip_one(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__skip_one(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__skip_one(SB) + +TEXT ·SkipOneFast(SB), NOSPLIT, $0 - 24 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__skip_one_fast(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__skip_one_fast(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__skip_one_fast(SB) + +TEXT ·GetByPath(SB), NOSPLIT, $0 - 32 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__get_by_path(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__get_by_path(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__get_by_path(SB) + +TEXT ·ValidateOne(SB), NOSPLIT, $0 - 32 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__validate_one(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__validate_one(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__validate_one(SB) + +TEXT ·ValidateUTF8(SB), NOSPLIT, $0 - 40 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__validate_utf8(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__validate_utf8(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__validate_utf8(SB) + +TEXT ·ValidateUTF8Fast(SB), NOSPLIT, $0 - 16 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__validate_utf8_fast(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__validate_utf8_fast(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__validate_utf8_fast(SB) + +TEXT ·I64toa(SB), NOSPLIT, $0 - 32 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__i64toa(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__i64toa(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__i64toa(SB) + +TEXT ·U64toa(SB), NOSPLIT, $0 - 32 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__u64toa(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__u64toa(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__u64toa(SB) + +TEXT ·F64toa(SB), NOSPLIT, $0 - 32 + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__f64toa(SB) + CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0 + JE 2(PC) + JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__f64toa(SB) + JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__f64toa(SB) + diff --git a/vendor/github.com/bytedance/sonic/internal/native/fastfloat_amd64_test.tmpl b/vendor/github.com/bytedance/sonic/internal/native/fastfloat_amd64_test.tmpl new file mode 100644 index 000000000..7ed9e4704 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/fastfloat_amd64_test.tmpl @@ -0,0 +1,138 @@ +/* + * 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 {{PACKAGE}} + +import ( + `math` + `strconv` + `testing` + `math/rand` + `encoding/json` + + `github.com/stretchr/testify/assert` +) + +func TestFastFloat_Encode(t *testing.T) { + var buf [64]byte + assert.Equal(t, "0" , string(buf[:__f64toa(&buf[0], 0)])) + assert.Equal(t, "-0" , string(buf[:__f64toa(&buf[0], math.Float64frombits(0x8000000000000000))])) + assert.Equal(t, "12340000000" , string(buf[:__f64toa(&buf[0], 1234e7)])) + assert.Equal(t, "12.34" , string(buf[:__f64toa(&buf[0], 1234e-2)])) + assert.Equal(t, "0.001234" , string(buf[:__f64toa(&buf[0], 1234e-6)])) + assert.Equal(t, "1e+30" , string(buf[:__f64toa(&buf[0], 1e30)])) + assert.Equal(t, "1.234e+33" , string(buf[:__f64toa(&buf[0], 1234e30)])) + assert.Equal(t, "1.234e+308" , string(buf[:__f64toa(&buf[0], 1234e305)])) + assert.Equal(t, "1.234e-317" , string(buf[:__f64toa(&buf[0], 1234e-320)])) + assert.Equal(t, "1.7976931348623157e+308" , string(buf[:__f64toa(&buf[0], 1.7976931348623157e308)])) + assert.Equal(t, "-12340000000" , string(buf[:__f64toa(&buf[0], -1234e7)])) + assert.Equal(t, "-12.34" , string(buf[:__f64toa(&buf[0], -1234e-2)])) + assert.Equal(t, "-0.001234" , string(buf[:__f64toa(&buf[0], -1234e-6)])) + assert.Equal(t, "-1e+30" , string(buf[:__f64toa(&buf[0], -1e30)])) + assert.Equal(t, "-1.234e+33" , string(buf[:__f64toa(&buf[0], -1234e30)])) + assert.Equal(t, "-1.234e+308" , string(buf[:__f64toa(&buf[0], -1234e305)])) + assert.Equal(t, "-1.234e-317" , string(buf[:__f64toa(&buf[0], -1234e-320)])) + assert.Equal(t, "-2.2250738585072014e-308" , string(buf[:__f64toa(&buf[0], -2.2250738585072014e-308)])) +} + +func TestFastFloat_Random(t *testing.T) { + var buf [64]byte + N := 10000 + for i := 0; i < N; i++ { + b64 := uint64(rand.Uint32())<<32 | uint64(rand.Uint32()) + f64 := math.Float64frombits(b64) + + jout, jerr := json.Marshal(f64) + n := __f64toa(&buf[0], f64) + if jerr == nil { + assert.Equal(t, jout, buf[:n]) + } else { + assert.True(t, n == 0) + } + + f32 := math.Float32frombits(rand.Uint32()) + jout, jerr = json.Marshal(f32) + n = __f32toa(&buf[0], f32) + if jerr == nil { + assert.Equal(t, jout, buf[:n]) + } else { + assert.True(t, n == 0) + } + } +} + +func BenchmarkParseFloat64(b *testing.B) { + var f64toaBenches = []struct { + name string + float float64 + }{ + {"Zero", 0}, + {"Decimal", 33909}, + {"Float", 339.7784}, + {"Exp", -5.09e75}, + {"NegExp", -5.11e-95}, + {"LongExp", 1.234567890123456e-78}, + {"Big", 123456789123456789123456789}, + + } + for _, c := range f64toaBenches { + f64bench := []struct { + name string + test func(*testing.B) + }{{ + name: "StdLib", + test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { strconv.AppendFloat(buf[:0], c.float, 'g', -1, 64) }}, + }, { + name: "FastFloat", + test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { __f64toa(&buf[0], c.float) }}, + }} + for _, bm := range f64bench { + name := bm.name + "_" + c.name + b.Run(name, bm.test) + } + } +} + +func BenchmarkParseFloat32(b *testing.B) { + var f32toaBenches = []struct { + name string + float float32 + }{ + {"Zero", 0}, + {"Integer", 33909}, + {"ExactFraction", 3.375}, + {"Point", 339.7784}, + {"Exp", -5.09e25}, + {"NegExp", -5.11e-25}, + {"Shortest", 1.234567e-8}, + } + for _, c := range f32toaBenches { + bench := []struct { + name string + test func(*testing.B) + }{{ + name: "StdLib32", + test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { strconv.AppendFloat(buf[:0], float64(c.float), 'g', -1, 32) }}, + }, { + name: "FastFloat32", + test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { __f32toa(&buf[0], c.float) }}, + }} + for _, bm := range bench { + name := bm.name + "_" + c.name + b.Run(name, bm.test) + } + } +}
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/native/fastint_amd64_test.tmpl b/vendor/github.com/bytedance/sonic/internal/native/fastint_amd64_test.tmpl new file mode 100644 index 000000000..cb060909d --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/fastint_amd64_test.tmpl @@ -0,0 +1,151 @@ +/* + * 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 {{PACKAGE}} + +import ( + `strconv` + `testing` + `fmt` + + `github.com/stretchr/testify/assert` +) + +func TestFastInt_IntToString(t *testing.T) { + var buf [32]byte + assert.Equal(t, "0" , string(buf[:__i64toa(&buf[0], 0)])) + assert.Equal(t, "1" , string(buf[:__i64toa(&buf[0], 1)])) + assert.Equal(t, "12" , string(buf[:__i64toa(&buf[0], 12)])) + assert.Equal(t, "123" , string(buf[:__i64toa(&buf[0], 123)])) + assert.Equal(t, "1234" , string(buf[:__i64toa(&buf[0], 1234)])) + assert.Equal(t, "12345" , string(buf[:__i64toa(&buf[0], 12345)])) + assert.Equal(t, "123456" , string(buf[:__i64toa(&buf[0], 123456)])) + assert.Equal(t, "1234567" , string(buf[:__i64toa(&buf[0], 1234567)])) + assert.Equal(t, "12345678" , string(buf[:__i64toa(&buf[0], 12345678)])) + assert.Equal(t, "123456789" , string(buf[:__i64toa(&buf[0], 123456789)])) + assert.Equal(t, "1234567890" , string(buf[:__i64toa(&buf[0], 1234567890)])) + assert.Equal(t, "12345678901" , string(buf[:__i64toa(&buf[0], 12345678901)])) + assert.Equal(t, "123456789012" , string(buf[:__i64toa(&buf[0], 123456789012)])) + assert.Equal(t, "1234567890123" , string(buf[:__i64toa(&buf[0], 1234567890123)])) + assert.Equal(t, "12345678901234" , string(buf[:__i64toa(&buf[0], 12345678901234)])) + assert.Equal(t, "123456789012345" , string(buf[:__i64toa(&buf[0], 123456789012345)])) + assert.Equal(t, "1234567890123456" , string(buf[:__i64toa(&buf[0], 1234567890123456)])) + assert.Equal(t, "12345678901234567" , string(buf[:__i64toa(&buf[0], 12345678901234567)])) + assert.Equal(t, "123456789012345678" , string(buf[:__i64toa(&buf[0], 123456789012345678)])) + assert.Equal(t, "1234567890123456789" , string(buf[:__i64toa(&buf[0], 1234567890123456789)])) + assert.Equal(t, "9223372036854775807" , string(buf[:__i64toa(&buf[0], 9223372036854775807)])) + assert.Equal(t, "-1" , string(buf[:__i64toa(&buf[0], -1)])) + assert.Equal(t, "-12" , string(buf[:__i64toa(&buf[0], -12)])) + assert.Equal(t, "-123" , string(buf[:__i64toa(&buf[0], -123)])) + assert.Equal(t, "-1234" , string(buf[:__i64toa(&buf[0], -1234)])) + assert.Equal(t, "-12345" , string(buf[:__i64toa(&buf[0], -12345)])) + assert.Equal(t, "-123456" , string(buf[:__i64toa(&buf[0], -123456)])) + assert.Equal(t, "-1234567" , string(buf[:__i64toa(&buf[0], -1234567)])) + assert.Equal(t, "-12345678" , string(buf[:__i64toa(&buf[0], -12345678)])) + assert.Equal(t, "-123456789" , string(buf[:__i64toa(&buf[0], -123456789)])) + assert.Equal(t, "-1234567890" , string(buf[:__i64toa(&buf[0], -1234567890)])) + assert.Equal(t, "-12345678901" , string(buf[:__i64toa(&buf[0], -12345678901)])) + assert.Equal(t, "-123456789012" , string(buf[:__i64toa(&buf[0], -123456789012)])) + assert.Equal(t, "-1234567890123" , string(buf[:__i64toa(&buf[0], -1234567890123)])) + assert.Equal(t, "-12345678901234" , string(buf[:__i64toa(&buf[0], -12345678901234)])) + assert.Equal(t, "-123456789012345" , string(buf[:__i64toa(&buf[0], -123456789012345)])) + assert.Equal(t, "-1234567890123456" , string(buf[:__i64toa(&buf[0], -1234567890123456)])) + assert.Equal(t, "-12345678901234567" , string(buf[:__i64toa(&buf[0], -12345678901234567)])) + assert.Equal(t, "-123456789012345678" , string(buf[:__i64toa(&buf[0], -123456789012345678)])) + assert.Equal(t, "-1234567890123456789" , string(buf[:__i64toa(&buf[0], -1234567890123456789)])) + assert.Equal(t, "-9223372036854775808" , string(buf[:__i64toa(&buf[0], -9223372036854775808)])) +} + +func TestFastInt_UintToString(t *testing.T) { + var buf [32]byte + assert.Equal(t, "0" , string(buf[:__u64toa(&buf[0], 0)])) + assert.Equal(t, "1" , string(buf[:__u64toa(&buf[0], 1)])) + assert.Equal(t, "12" , string(buf[:__u64toa(&buf[0], 12)])) + assert.Equal(t, "123" , string(buf[:__u64toa(&buf[0], 123)])) + assert.Equal(t, "1234" , string(buf[:__u64toa(&buf[0], 1234)])) + assert.Equal(t, "12345" , string(buf[:__u64toa(&buf[0], 12345)])) + assert.Equal(t, "123456" , string(buf[:__u64toa(&buf[0], 123456)])) + assert.Equal(t, "1234567" , string(buf[:__u64toa(&buf[0], 1234567)])) + assert.Equal(t, "12345678" , string(buf[:__u64toa(&buf[0], 12345678)])) + assert.Equal(t, "123456789" , string(buf[:__u64toa(&buf[0], 123456789)])) + assert.Equal(t, "1234567890" , string(buf[:__u64toa(&buf[0], 1234567890)])) + assert.Equal(t, "12345678901" , string(buf[:__u64toa(&buf[0], 12345678901)])) + assert.Equal(t, "123456789012" , string(buf[:__u64toa(&buf[0], 123456789012)])) + assert.Equal(t, "1234567890123" , string(buf[:__u64toa(&buf[0], 1234567890123)])) + assert.Equal(t, "12345678901234" , string(buf[:__u64toa(&buf[0], 12345678901234)])) + assert.Equal(t, "123456789012345" , string(buf[:__u64toa(&buf[0], 123456789012345)])) + assert.Equal(t, "1234567890123456" , string(buf[:__u64toa(&buf[0], 1234567890123456)])) + assert.Equal(t, "12345678901234567" , string(buf[:__u64toa(&buf[0], 12345678901234567)])) + assert.Equal(t, "123456789012345678" , string(buf[:__u64toa(&buf[0], 123456789012345678)])) + assert.Equal(t, "1234567890123456789" , string(buf[:__u64toa(&buf[0], 1234567890123456789)])) + assert.Equal(t, "12345678901234567890" , string(buf[:__u64toa(&buf[0], 12345678901234567890)])) + assert.Equal(t, "18446744073709551615" , string(buf[:__u64toa(&buf[0], 18446744073709551615)])) +} + + func BenchmarkFastInt_IntToString(b *testing.B) { + benchmarks := []struct { + name string + test func(*testing.B) + }{{ + name: "StdLib-Positive", + test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendInt(buf[:0], int64(i), 10) }}, + }, { + name: "StdLib-Negative", + test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendInt(buf[:0], -int64(i), 10) }}, + }, { + name: "FastInt-Positive", + test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { __i64toa(&buf[0], int64(i)) }}, + }, { + name: "FastInt-Negative", + test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { __i64toa(&buf[0], -int64(i)) }}, + }} + for _, bm := range benchmarks { + b.Run(bm.name, bm.test) + } + } + + type utoaBench struct { + name string + num uint64 + } + + func BenchmarkFastInt_UintToString(b *testing.B) { + maxUint := "18446744073709551615" + benchs := make([]utoaBench, len(maxUint) + 1) + benchs[0].name = "Zero" + benchs[0].num = 0 + for i := 1; i <= len(maxUint); i++ { + benchs[i].name = strconv.FormatInt(int64(i), 10) + "-Digs" + benchs[i].num, _ = strconv.ParseUint(string(maxUint[:i]), 10, 64) + } + + for _, t := range(benchs) { + benchmarks := []struct { + name string + test func(*testing.B) + }{{ + name: "StdLib", + test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendUint(buf[:0], t.num, 10) }}, + }, { + name: "FastInt", + test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { __u64toa(&buf[0], t.num) }}, + }} + for _, bm := range benchmarks { + name := fmt.Sprintf("%s_%s", bm.name, t.name) + b.Run(name, bm.test) + } + } + }
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl b/vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl new file mode 100644 index 000000000..357a9f480 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl @@ -0,0 +1,133 @@ +/* + * 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 {{PACKAGE}} + +import ( + `unsafe` + + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __i64toa(out *byte, val int64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __u64toa(out *byte, val uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __f64toa(out *byte, val float64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __f32toa(out *byte, val float32) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __lspace(sp unsafe.Pointer, nb int, off int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vstring(s *string, p *int, v *types.JsonState, flags uint64) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vnumber(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vsigned(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vunsigned(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_one_fast(s *string, p *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_number(s *string, p *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_one(s *string, p *int, m *types.StateMachine) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __get_by_path(s *string, p *int, path *[]interface{}) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_utf8_fast(s *string) (ret int)
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/native/native_amd64_test.tmpl b/vendor/github.com/bytedance/sonic/internal/native/native_amd64_test.tmpl new file mode 100644 index 000000000..bd9ce0c73 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/native_amd64_test.tmpl @@ -0,0 +1,593 @@ +/* + * 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 {{PACKAGE}} + +import ( + `encoding/hex` + `fmt` + `math` + `testing` + `unsafe` + + `github.com/bytedance/sonic/internal/native/types` + `github.com/bytedance/sonic/internal/rt` + `github.com/davecgh/go-spew/spew` + `github.com/stretchr/testify/assert` + `github.com/stretchr/testify/require` +) + +func TestNative_Value(t *testing.T) { + var v types.JsonState + s := ` -12345` + p := (*rt.GoString)(unsafe.Pointer(&s)) + x := __value(p.Ptr, p.Len, 0, &v, 0) + assert.Equal(t, 9, x) + assert.Equal(t, types.V_INTEGER, v.Vt) + assert.Equal(t, int64(-12345), v.Iv) + assert.Equal(t, 3, v.Ep) +} + +func TestNative_Value_OutOfBound(t *testing.T) { + var v types.JsonState + mem := []byte{'"', '"'} + s := rt.Mem2Str(mem[:1]) + p := (*rt.GoString)(unsafe.Pointer(&s)) + x := __value(p.Ptr, p.Len, 0, &v, 0) + assert.Equal(t, 1, x) + assert.Equal(t, -int(types.ERR_EOF), int(v.Vt)) +} + +func TestNative_Quote(t *testing.T) { + s := "hello\b\f\n\r\t\\\"\u666fworld" + d := make([]byte, 256) + dp := (*rt.GoSlice)(unsafe.Pointer(&d)) + sp := (*rt.GoString)(unsafe.Pointer(&s)) + rv := __quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0) + if rv < 0 { + require.NoError(t, types.ParsingError(-rv)) + } + assert.Equal(t, len(s), rv) + assert.Equal(t, 35, len(d)) + assert.Equal(t, `hello\u0008\u000c\n\r\t\\\"景world`, string(d)) +} + +func TestNative_QuoteNoMem(t *testing.T) { + s := "hello\b\f\n\r\t\\\"\u666fworld" + d := make([]byte, 10) + dp := (*rt.GoSlice)(unsafe.Pointer(&d)) + sp := (*rt.GoString)(unsafe.Pointer(&s)) + rv := __quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0) + assert.Equal(t, -6, rv) + assert.Equal(t, 5, len(d)) + assert.Equal(t, `hello`, string(d)) +} + +func TestNative_DoubleQuote(t *testing.T) { + s := "hello\b\f\n\r\t\\\"\u666fworld" + d := make([]byte, 256) + dp := (*rt.GoSlice)(unsafe.Pointer(&d)) + sp := (*rt.GoString)(unsafe.Pointer(&s)) + rv := __quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, types.F_DOUBLE_UNQUOTE) + if rv < 0 { + require.NoError(t, types.ParsingError(-rv)) + } + assert.Equal(t, len(s), rv) + assert.Equal(t, 44, len(d)) + assert.Equal(t, `hello\\u0008\\u000c\\n\\r\\t\\\\\\\"景world`, string(d)) +} + +func TestNative_Unquote(t *testing.T) { + s := `hello\b\f\n\r\t\\\"\u2333world` + d := make([]byte, 0, len(s)) + ep := -1 + dp := (*rt.GoSlice)(unsafe.Pointer(&d)) + sp := (*rt.GoString)(unsafe.Pointer(&s)) + rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0) + if rv < 0 { + require.NoError(t, types.ParsingError(-rv)) + } + dp.Len = rv + assert.Equal(t, -1, ep) + assert.Equal(t, "hello\b\f\n\r\t\\\"\u2333world", string(d)) +} + +func TestNative_UnquoteError(t *testing.T) { + s := `asdf\` + d := make([]byte, 0, len(s)) + ep := -1 + dp := (*rt.GoSlice)(unsafe.Pointer(&d)) + sp := (*rt.GoString)(unsafe.Pointer(&s)) + rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0) + assert.Equal(t, -int(types.ERR_EOF), rv) + assert.Equal(t, 5, ep) + s = `asdf\gqwer` + d = make([]byte, 0, len(s)) + ep = -1 + dp = (*rt.GoSlice)(unsafe.Pointer(&d)) + sp = (*rt.GoString)(unsafe.Pointer(&s)) + rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0) + assert.Equal(t, -int(types.ERR_INVALID_ESCAPE), rv) + assert.Equal(t, 5, ep) + s = `asdf\u1gggqwer` + d = make([]byte, 0, len(s)) + ep = -1 + dp = (*rt.GoSlice)(unsafe.Pointer(&d)) + sp = (*rt.GoString)(unsafe.Pointer(&s)) + rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0) + assert.Equal(t, -int(types.ERR_INVALID_CHAR), rv) + assert.Equal(t, 7, ep) + s = `asdf\ud800qwer` + d = make([]byte, 0, len(s)) + ep = -1 + dp = (*rt.GoSlice)(unsafe.Pointer(&d)) + sp = (*rt.GoString)(unsafe.Pointer(&s)) + rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0) + assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv) + assert.Equal(t, 6, ep) + s = `asdf\\ud800qwer` + d = make([]byte, 0, len(s)) + ep = -1 + dp = (*rt.GoSlice)(unsafe.Pointer(&d)) + sp = (*rt.GoString)(unsafe.Pointer(&s)) + rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE) + assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv) + assert.Equal(t, 7, ep) + s = `asdf\ud800\ud800qwer` + d = make([]byte, 0, len(s)) + ep = -1 + dp = (*rt.GoSlice)(unsafe.Pointer(&d)) + sp = (*rt.GoString)(unsafe.Pointer(&s)) + rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0) + assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv) + assert.Equal(t, 12, ep) + s = `asdf\\ud800\\ud800qwer` + d = make([]byte, 0, len(s)) + ep = -1 + dp = (*rt.GoSlice)(unsafe.Pointer(&d)) + sp = (*rt.GoString)(unsafe.Pointer(&s)) + rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE) + assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv) + assert.Equal(t, 14, ep) +} + +func TestNative_DoubleUnquote(t *testing.T) { + s := `hello\\b\\f\\n\\r\\t\\\\\\\"\\u2333world` + d := make([]byte, 0, len(s)) + ep := -1 + dp := (*rt.GoSlice)(unsafe.Pointer(&d)) + sp := (*rt.GoString)(unsafe.Pointer(&s)) + rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE) + if rv < 0 { + require.NoError(t, types.ParsingError(-rv)) + } + dp.Len = rv + assert.Equal(t, -1, ep) + assert.Equal(t, "hello\b\f\n\r\t\\\"\u2333world", string(d)) +} + +func TestNative_UnquoteUnicodeReplacement(t *testing.T) { + s := `hello\ud800world` + d := make([]byte, 0, len(s)) + ep := -1 + dp := (*rt.GoSlice)(unsafe.Pointer(&d)) + sp := (*rt.GoString)(unsafe.Pointer(&s)) + rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE) + if rv < 0 { + require.NoError(t, types.ParsingError(-rv)) + } + dp.Len = rv + assert.Equal(t, -1, ep) + assert.Equal(t, "hello\ufffdworld", string(d)) + s = `hello\ud800\ud800world` + d = make([]byte, 0, len(s)) + ep = -1 + dp = (*rt.GoSlice)(unsafe.Pointer(&d)) + sp = (*rt.GoString)(unsafe.Pointer(&s)) + rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE) + if rv < 0 { + require.NoError(t, types.ParsingError(-rv)) + } + dp.Len = rv + assert.Equal(t, -1, ep) + assert.Equal(t, "hello\ufffd\ufffdworld", string(d)) +} + +func TestNative_HTMLEscape(t *testing.T) { + s := "hello\u2029\u2028<&>world" + d := make([]byte, 256) + dp := (*rt.GoSlice)(unsafe.Pointer(&d)) + sp := (*rt.GoString)(unsafe.Pointer(&s)) + rv := __html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len) + if rv < 0 { + require.NoError(t, types.ParsingError(-rv)) + } + assert.Equal(t, len(s), rv) + assert.Equal(t, 40, len(d)) + assert.Equal(t, `hello\u2029\u2028\u003c\u0026\u003eworld`, string(d)) +} + +func TestNative_HTMLEscapeNoMem(t *testing.T) { + s := "hello\u2029\u2028<&>world" + d := make([]byte, 10) + dp := (*rt.GoSlice)(unsafe.Pointer(&d)) + sp := (*rt.GoString)(unsafe.Pointer(&s)) + rv := __html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len) + assert.Equal(t, -6, rv) + assert.Equal(t, 5, len(d)) + assert.Equal(t, `hello`, string(d)) +} + +func TestNative_Vstring(t *testing.T) { + var v types.JsonState + i := 0 + s := `test"test\n2"` + __vstring(&s, &i, &v, 0) + assert.Equal(t, 5, i) + assert.Equal(t, -1, v.Ep) + assert.Equal(t, int64(0), v.Iv) + __vstring(&s, &i, &v, 0) + assert.Equal(t, 13, i) + assert.Equal(t, 9, v.Ep) + assert.Equal(t, int64(5), v.Iv) +} + +func TestNative_Vstring_ValidUnescapedChars(t *testing.T) { + var v types.JsonState + valid := uint64(types.F_VALIDATE_STRING) + i := 0 + s := "test\x1f\"" + __vstring(&s, &i, &v, valid) + assert.Equal(t, -int(types.ERR_INVALID_CHAR), int(v.Vt)) +} + +func TestNative_VstringEscapeEOF(t *testing.T) { + var v types.JsonState + i := 0 + s := `xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"x` + __vstring(&s, &i, &v, 0) + assert.Equal(t, 95, i) + assert.Equal(t, 63, v.Ep) + assert.Equal(t, int64(0), v.Iv) +} + +func TestNative_VstringHangUpOnRandomData(t *testing.T) { + v, e := hex.DecodeString( + "228dc61efd54ef80a908fb6026b7f2d5f92a257ba8b347c995f259eb8685376a" + + "8c4500262d9c308b3f3ec2577689cf345d9f86f9b5d18d3e463bec5c22df2d2e" + + "4506010eba1dae7278", + ) + assert.Nil(t, e) + p := 1 + s := rt.Mem2Str(v) + var js types.JsonState + __vstring(&s, &p, &js, 0) + fmt.Printf("js: %s\n", spew.Sdump(js)) +} + +func TestNative_Vnumber(t *testing.T) { + var v types.JsonState + i := 0 + s := "1234" + __vnumber(&s, &i, &v) + assert.Equal(t, 4, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, int64(1234), v.Iv) + assert.Equal(t, types.V_INTEGER, v.Vt) + i = 0 + s = "1.234" + __vnumber(&s, &i, &v) + assert.Equal(t, 5, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, 1.234, v.Dv) + assert.Equal(t, types.V_DOUBLE, v.Vt) + i = 0 + s = "1.234e5" + __vnumber(&s, &i, &v) + assert.Equal(t, 7, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, 1.234e5, v.Dv) + assert.Equal(t, types.V_DOUBLE, v.Vt) + i = 0 + s = "0.0125" + __vnumber(&s, &i, &v) + assert.Equal(t, 6, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, 0.0125, v.Dv) + assert.Equal(t, types.V_DOUBLE, v.Vt) + i = 0 + s = "100000000000000000000" + __vnumber(&s, &i, &v) + assert.Equal(t, 21, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, 100000000000000000000.0, v.Dv) + assert.Equal(t, types.V_DOUBLE, v.Vt) + i = 0 + s = "999999999999999900000" + __vnumber(&s, &i, &v) + assert.Equal(t, 21, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, 999999999999999900000.0, v.Dv) + assert.Equal(t, types.V_DOUBLE, v.Vt) + i = 0 + s = "-1.234" + __vnumber(&s, &i, &v) + assert.Equal(t, 6, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, -1.234, v.Dv) + assert.Equal(t, types.V_DOUBLE, v.Vt) +} + +func TestNative_Vsigned(t *testing.T) { + var v types.JsonState + i := 0 + s := "1234" + __vsigned(&s, &i, &v) + assert.Equal(t, 4, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, int64(1234), v.Iv) + assert.Equal(t, types.V_INTEGER, v.Vt) + i = 0 + s = "-1234" + __vsigned(&s, &i, &v) + assert.Equal(t, 5, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, int64(-1234), v.Iv) + assert.Equal(t, types.V_INTEGER, v.Vt) + i = 0 + s = "9223372036854775807" + __vsigned(&s, &i, &v) + assert.Equal(t, 19, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, int64(math.MaxInt64), v.Iv) + assert.Equal(t, types.V_INTEGER, v.Vt) + i = 0 + s = "-9223372036854775808" + __vsigned(&s, &i, &v) + assert.Equal(t, 20, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, int64(math.MinInt64), v.Iv) + assert.Equal(t, types.V_INTEGER, v.Vt) + i = 0 + s = "9223372036854775808" + __vsigned(&s, &i, &v) + assert.Equal(t, 18, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt) + i = 0 + s = "-9223372036854775809" + __vsigned(&s, &i, &v) + assert.Equal(t, 19, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt) + i = 0 + s = "1.234" + __vsigned(&s, &i, &v) + assert.Equal(t, 1, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) + i = 0 + s = "0.0125" + __vsigned(&s, &i, &v) + assert.Equal(t, 1, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) + i = 0 + s = "-1234e5" + __vsigned(&s, &i, &v) + assert.Equal(t, 5, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) + i = 0 + s = "-1234e-5" + __vsigned(&s, &i, &v) + assert.Equal(t, 5, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) +} + +func TestNative_Vunsigned(t *testing.T) { + var v types.JsonState + i := 0 + s := "1234" + __vunsigned(&s, &i, &v) + assert.Equal(t, 4, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, int64(1234), v.Iv) + assert.Equal(t, types.V_INTEGER, v.Vt) + i = 0 + s = "18446744073709551615" + __vunsigned(&s, &i, &v) + assert.Equal(t, 20, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, ^int64(0), v.Iv) + assert.Equal(t, types.V_INTEGER, v.Vt) + i = 0 + s = "18446744073709551616" + __vunsigned(&s, &i, &v) + assert.Equal(t, 19, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt) + i = 0 + s = "-1234" + __vunsigned(&s, &i, &v) + assert.Equal(t, 0, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) + i = 0 + s = "1.234" + __vunsigned(&s, &i, &v) + assert.Equal(t, 1, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) + i = 0 + s = "0.0125" + __vunsigned(&s, &i, &v) + assert.Equal(t, 1, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) + i = 0 + s = "1234e5" + __vunsigned(&s, &i, &v) + assert.Equal(t, 4, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) + i = 0 + s = "-1234e5" + __vunsigned(&s, &i, &v) + assert.Equal(t, 0, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) + i = 0 + s = "-1.234e5" + __vunsigned(&s, &i, &v) + assert.Equal(t, 0, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) + i = 0 + s = "-1.234e-5" + __vunsigned(&s, &i, &v) + assert.Equal(t, 0, i) + assert.Equal(t, 0, v.Ep) + assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt) +} + +func TestNative_SkipOne(t *testing.T) { + p := 0 + s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5` + q := __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, 42, p) + assert.Equal(t, 1, q) + p = 0 + s = `1 2.5 -3 "asdf\nqwer" true false null {} []` + q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, 1, p) + assert.Equal(t, 0, q) + q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, 5, p) + assert.Equal(t, 2, q) + q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, 8, p) + assert.Equal(t, 6, q) + q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, 21, p) + assert.Equal(t, 9, q) + q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, 26, p) + assert.Equal(t, 22, q) + q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, 32, p) + assert.Equal(t, 27, q) + q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, 37, p) + assert.Equal(t, 33, q) + q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, 40, p) + assert.Equal(t, 38, q) + q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, 43, p) + assert.Equal(t, 41, q) +} + +func TestNative_SkipOne_Error(t *testing.T) { + for _, s := range([]string{ + "-", "+", "0.", "0. ", "+1", "0.0e ", "9e+", "0e-", + "tru", "fals", "nul", "trux", "fals ", + `"asdf`, `"\\\"`, + }) { + p := 0 + q := __skip_one(&s, &p, &types.StateMachine{}, uint64(0)) + assert.True(t, q < 0) + } +} + +func TestNative_SkipArray(t *testing.T) { + p := 0 + s := `null, true, false, 1, 2.0, -3, {"asdf": "wqer"}],` + __skip_array(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, p, 48) +} + +func TestNative_SkipObject(t *testing.T) { + p := 0 + s := `"asdf": "wqer"},` + __skip_object(&s, &p, &types.StateMachine{}, uint64(0)) + assert.Equal(t, p, 15) +} + +func TestNative_SkipNumber(t *testing.T) { + p := 0 + s := `-1.23e+12` + q := __skip_number(&s, &p) + assert.Equal(t, 9, p) + assert.Equal(t, 0, q) +} + +func TestNative_SkipOneFast(t *testing.T) { + p := 0 + s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5` + q := __skip_one_fast(&s, &p) + assert.Equal(t, 42, p) + assert.Equal(t, 1, q) + p = 0 + s = `1, 2.5, -3, "asdf\nqwer", true, false, null, {}, [],` + q = __skip_one_fast(&s, &p) + assert.Equal(t, 1, p) + assert.Equal(t, 0, q) + p += 1 + q = __skip_one_fast(&s, &p) + assert.Equal(t, 6, p) + assert.Equal(t, 3, q) + p += 1 + q = __skip_one_fast(&s, &p) + assert.Equal(t, 10, p) + assert.Equal(t, 8, q) + p += 1 + q = __skip_one_fast(&s, &p) + assert.Equal(t, 24, p) + assert.Equal(t, 12, q) + p += 1 + q = __skip_one_fast(&s, &p) + assert.Equal(t, 30, p) + assert.Equal(t, 26, q) + p += 1 + q = __skip_one_fast(&s, &p) + assert.Equal(t, 37, p) + assert.Equal(t, 32, q) + p += 1 + q = __skip_one_fast(&s, &p) + assert.Equal(t, 43, p) + assert.Equal(t, 39, q) + p += 1 + q = __skip_one_fast(&s, &p) + assert.Equal(t, 47, p) + assert.Equal(t, 45, q) + p += 1 + q = __skip_one_fast(&s, &p) + assert.Equal(t, 51, p) + assert.Equal(t, 49, q) +} + +func TestNative_SkipOneFast_Error(t *testing.T) { + for _, s := range([]string{ + "{{", "[{", "{{}", + `"asdf`, `"\\\"`, + }) { + p := 0 + q := __skip_one_fast(&s, &p) + assert.True(t, q < 0) + } +}
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/native/native_export_amd64.tmpl b/vendor/github.com/bytedance/sonic/internal/native/native_export_amd64.tmpl new file mode 100644 index 000000000..c7a10de94 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/native_export_amd64.tmpl @@ -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 {{PACKAGE}} + +var ( + S_f64toa = _subr__f64toa + S_f32toa = _subr__f32toa + S_i64toa = _subr__i64toa + S_u64toa = _subr__u64toa + S_lspace = _subr__lspace +) + +var ( + S_quote = _subr__quote + S_unquote = _subr__unquote +) + +var ( + S_value = _subr__value + S_vstring = _subr__vstring + S_vnumber = _subr__vnumber + S_vsigned = _subr__vsigned + S_vunsigned = _subr__vunsigned +) + +var ( + S_skip_one = _subr__skip_one + S_skip_one_fast = _subr__skip_one_fast + S_skip_array = _subr__skip_array + S_skip_object = _subr__skip_object + S_skip_number = _subr__skip_number + S_get_by_path = _subr__get_by_path +) diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go new file mode 100644 index 000000000..4cd4b0c7f --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go @@ -0,0 +1,135 @@ +// 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 sse + +import ( + `unsafe` + + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __i64toa(out *byte, val int64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __u64toa(out *byte, val uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __f64toa(out *byte, val float64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __f32toa(out *byte, val float32) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __lspace(sp unsafe.Pointer, nb int, off int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vstring(s *string, p *int, v *types.JsonState, flags uint64) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vnumber(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vsigned(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vunsigned(s *string, p *int, v *types.JsonState) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_one_fast(s *string, p *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_number(s *string, p *int) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_one(s *string, p *int, m *types.StateMachine) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __get_by_path(s *string, p *int, path *[]interface{}) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_utf8_fast(s *string) (ret int)
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.s new file mode 100644 index 000000000..08a68f957 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.s @@ -0,0 +1,15078 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__native_entry__(SB), NOSPLIT, $0 + NO_LOCAL_POINTERS + LONG $0xf9058d48; WORD $0xffff; BYTE $0xff // leaq $-7(%rip), %rax + LONG $0x24448948; BYTE $0x08 // movq %rax, $8(%rsp) + BYTE $0xc3 // retq + WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI0_0: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + +LCPI0_1: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI0_2: + QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' + +LCPI0_3: + QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + + // .p2align 4, 0x90 +_lspace: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + LONG $0x0066840f; WORD $0x0000 // je LBB0_7, $102(%rip) + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xe183; BYTE $0x0f // andl $15, %ecx + LONG $0x005a840f; WORD $0x0000 // je LBB0_7, $90(%rip) + LONG $0x014f8d4c // leaq $1(%rdi), %r9 + LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx + QUAD $0x000100002600b849; WORD $0x0000 // movabsq $4294977024, %r8 + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB0_3: + LONG $0x0714be0f // movsbl (%rdi,%rax), %edx + WORD $0xfa83; BYTE $0x20 // cmpl $32, %edx + LONG $0x0100870f; WORD $0x0000 // ja LBB0_22, $256(%rip) + LONG $0xd0a30f49 // btq %rdx, %r8 + LONG $0x00f6830f; WORD $0x0000 // jae LBB0_22, $246(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x000f840f; WORD $0x0000 // je LBB0_6, $15(%rip) + WORD $0x0144; BYTE $0xc8 // addl %r9d, %eax + WORD $0xe083; BYTE $0x0f // andl $15, %eax + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0xffcd850f; WORD $0xffff // jne LBB0_3, $-51(%rip) + +LBB0_6: + LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 + WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + +LBB0_7: + LONG $0x10fa8348 // cmpq $16, %rdx + LONG $0x007a820f; WORD $0x0000 // jb LBB0_13, $122(%rip) + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi + QUAD $0xffffff2b056f0f66 // movdqa $-213(%rip), %xmm0 /* LCPI0_0(%rip) */ + QUAD $0xffffff330d6f0f66 // movdqa $-205(%rip), %xmm1 /* LCPI0_1(%rip) */ + QUAD $0xffffff3b156f0f66 // movdqa $-197(%rip), %xmm2 /* LCPI0_2(%rip) */ + QUAD $0xffffff431d6f0f66 // movdqa $-189(%rip), %xmm3 /* LCPI0_3(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB0_9: + LONG $0x6f0f4166; BYTE $0x22 // movdqa (%r10), %xmm4 + LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 + LONG $0xe8740f66 // pcmpeqb %xmm0, %xmm5 + LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 + LONG $0xf1740f66 // pcmpeqb %xmm1, %xmm6 + LONG $0xf5eb0f66 // por %xmm5, %xmm6 + LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 + LONG $0xea740f66 // pcmpeqb %xmm2, %xmm5 + LONG $0xe3740f66 // pcmpeqb %xmm3, %xmm4 + LONG $0xe5eb0f66 // por %xmm5, %xmm4 + LONG $0xe6eb0f66 // por %xmm6, %xmm4 + LONG $0xc4d70f66 // pmovmskb %xmm4, %eax + LONG $0xfff88366 // cmpw $-1, %ax + LONG $0x0064850f; WORD $0x0000 // jne LBB0_10, $100(%rip) + LONG $0x10c28349 // addq $16, %r10 + LONG $0xf0c28348 // addq $-16, %rdx + LONG $0xf0c68348 // addq $-16, %rsi + LONG $0x0ffa8348 // cmpq $15, %rdx + LONG $0xffaf870f; WORD $0xffff // ja LBB0_9, $-81(%rip) + +LBB0_13: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x003d840f; WORD $0x0000 // je LBB0_20, $61(%rip) + LONG $0x12048d4d // leaq (%r10,%rdx), %r8 + WORD $0xc031 // xorl %eax, %eax + QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB0_15: + LONG $0x34be0f41; BYTE $0x02 // movsbl (%r10,%rax), %esi + WORD $0xfe83; BYTE $0x20 // cmpl $32, %esi + LONG $0x002e870f; WORD $0x0000 // ja LBB0_17, $46(%rip) + LONG $0xf1a30f49 // btq %rsi, %r9 + LONG $0x0024830f; WORD $0x0000 // jae LBB0_17, $36(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx + LONG $0xffdc850f; WORD $0xffff // jne LBB0_15, $-36(%rip) + WORD $0x894d; BYTE $0xc2 // movq %r8, %r10 + +LBB0_20: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + +LBB0_21: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + +LBB0_22: + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB0_10: + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0xd0f7 // notl %eax + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax + WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB0_17: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + LONG $0xffffe3e9; BYTE $0xff // jmp LBB0_21, $-29(%rip) + QUAD $0x0000000000000000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI1_0: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x90 +_f64toa: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + LONG $0x7e0f4866; BYTE $0xc2 // movq %xmm0, %rdx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x34e8c148 // shrq $52, %rax + LONG $0x0007ff25; BYTE $0x00 // andl $2047, %eax + LONG $0x0007ff3d; BYTE $0x00 // cmpl $2047, %eax + LONG $0x0acb840f; WORD $0x0000 // je LBB1_1, $2763(%rip) + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 + LONG $0x3fedc149 // shrq $63, %r13 + LONG $0x2f3c8d4e // leaq (%rdi,%r13), %r15 + QUAD $0x00000000550c8d48 // leaq (,%rdx,2), %rcx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x01f5840f; WORD $0x0000 // je LBB1_3, $501(%rip) + QUAD $0xffffffffffffbf48; WORD $0x000f // movabsq $4503599627370495, %rdi + WORD $0x2148; BYTE $0xfa // andq %rdi, %rdx + WORD $0xc085 // testl %eax, %eax + LONG $0xd0758948 // movq %rsi, $-48(%rbp) + LONG $0x0a97840f; WORD $0x0000 // je LBB1_5, $2711(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0x0948; BYTE $0xd7 // orq %rdx, %rdi + LONG $0xfbcdb08d; WORD $0xffff // leal $-1075(%rax), %esi + LONG $0xfc01888d; WORD $0xffff // leal $-1023(%rax), %ecx + WORD $0xf983; BYTE $0x34 // cmpl $52, %ecx + LONG $0x001d870f; WORD $0x0000 // ja LBB1_6, $29(%rip) + LONG $0x000433b9; BYTE $0x00 // movl $1075, %ecx + WORD $0xc129 // subl %eax, %ecx + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx + WORD $0xf748; BYTE $0xd3 // notq %rbx + WORD $0x8548; BYTE $0xdf // testq %rbx, %rdi + LONG $0x0421840f; WORD $0x0000 // je LBB1_11, $1057(%rip) + +LBB1_6: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + WORD $0x940f; BYTE $0xc1 // sete %cl + WORD $0xf883; BYTE $0x02 // cmpl $2, %eax + WORD $0x930f; BYTE $0xc0 // setae %al + WORD $0xc820 // andb %cl, %al + QUAD $0x00000000bd0c8d4c // leaq (,%rdi,4), %r9 + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + LONG $0xb81c8d48 // leaq (%rax,%rdi,4), %rbx + LONG $0xfec38348 // addq $-2, %rbx + LONG $0x4413ce69; WORD $0x0013 // imull $1262611, %esi, %ecx + LONG $0x01918d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rcx), %r10d + WORD $0xc084 // testb %al, %al + LONG $0xd1440f44 // cmovel %ecx, %r10d + QUAD $0x00000002bd048d4c // leaq $2(,%rdi,4), %r8 + LONG $0x16fac141 // sarl $22, %r10d + LONG $0xb1ca6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r10d, %ecx + WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx + WORD $0xf101 // addl %esi, %ecx + LONG $0x000124b8; BYTE $0x00 // movl $292, %eax + WORD $0x2944; BYTE $0xd0 // subl %r10d, %eax + LONG $0x04e0c148 // shlq $4, %rax + LONG $0xd4158d48; WORD $0x00b2; BYTE $0x00 // leaq $45780(%rip), %rdx /* _pow10_ceil_sig.g(%rip) */ + LONG $0x101c8b4c // movq (%rax,%rdx), %r11 + LONG $0x10748b4c; BYTE $0x08 // movq $8(%rax,%rdx), %r14 + WORD $0xc1fe // incb %cl + WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0x00d28348 // adcq $0, %rdx + WORD $0xf631 // xorl %esi, %esi + LONG $0xfffea948; WORD $0xffff // testq $-2, %rax + LONG $0xc6950f40 // setne %sil + WORD $0x0948; BYTE $0xd6 // orq %rdx, %rsi + WORD $0xd349; BYTE $0xe1 // shlq %cl, %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0x00d18349 // adcq $0, %r9 + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xfffea948; WORD $0xffff // testq $-2, %rax + WORD $0x950f; BYTE $0xc3 // setne %bl + WORD $0x094c; BYTE $0xcb // orq %r9, %rbx + WORD $0xd349; BYTE $0xe0 // shlq %cl, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0x00d28348 // adcq $0, %rdx + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xfffea948; WORD $0xffff // testq $-2, %rax + WORD $0x950f; BYTE $0xc1 // setne %cl + WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx + WORD $0xe783; BYTE $0x01 // andl $1, %edi + WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi + WORD $0x2948; BYTE $0xf9 // subq %rdi, %rcx + LONG $0x28fb8348 // cmpq $40, %rbx + LONG $0x0043820f; WORD $0x0000 // jb LBB1_28, $67(%rip) + QUAD $0xcccccccccccdba48; WORD $0xcccc // movabsq $-3689348814741910323, %rdx + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xe2 // mulq %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0x05efc148 // shrq $5, %rdi + QUAD $0x00000000fd048d48 // leaq (,%rdi,8), %rax + LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xc0970f41 // seta %r8b + LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx + LONG $0x28c28348 // addq $40, %rdx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xca // cmpq %rcx, %rdx + WORD $0x960f; BYTE $0xc2 // setbe %dl + WORD $0x3841; BYTE $0xd0 // cmpb %dl, %r8b + LONG $0x0134840f; WORD $0x0000 // je LBB1_8, $308(%rip) + +LBB1_28: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + LONG $0x02e8c149 // shrq $2, %r8 + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + LONG $0xfce28348 // andq $-4, %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xc7970f40 // seta %dil + LONG $0x04728d48 // leaq $4(%rdx), %rsi + WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi + WORD $0x960f; BYTE $0xc0 // setbe %al + WORD $0x3040; BYTE $0xf8 // xorb %dil, %al + LONG $0x0055840f; WORD $0x0000 // je LBB1_29, $85(%rip) + LONG $0x02ca8348 // orq $2, %rdx + LONG $0x000001bf; BYTE $0x00 // movl $1, %edi + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0x000e870f; WORD $0x0000 // ja LBB1_32, $14(%rip) + WORD $0x940f; BYTE $0xc0 // sete %al + LONG $0x02e9c041 // shrb $2, %r9b + WORD $0x2041; BYTE $0xc1 // andb %al, %r9b + LONG $0xf9b60f41 // movzbl %r9b, %edi + +LBB1_32: + WORD $0x014c; BYTE $0xc7 // addq %r8, %rdi + QUAD $0x0001ffffffe0bc49; WORD $0x0000 // movabsq $8589934560, %r12 + QUAD $0x540be41f24848d49 // leaq $1410065439(%r12), %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x003c870f; WORD $0x0000 // ja LBB1_34, $60(%rip) + LONG $0x0000ece9; BYTE $0x00 // jmp LBB1_40, $236(%rip) + +LBB1_3: + LONG $0x3007c641 // movb $48, (%r15) + WORD $0x2941; BYTE $0xf7 // subl %esi, %r15d + WORD $0xff41; BYTE $0xc7 // incl %r15d + WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx + LONG $0x000891e9; BYTE $0x00 // jmp LBB1_123, $2193(%rip) + +LBB1_29: + WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx + LONG $0xffd88349 // sbbq $-1, %r8 + WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi + QUAD $0x0001ffffffe0bc49; WORD $0x0000 // movabsq $8589934560, %r12 + QUAD $0x540be41f24848d49 // leaq $1410065439(%r12), %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00b5860f; WORD $0x0000 // jbe LBB1_40, $181(%rip) + +LBB1_34: + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0be8c148 // shrq $11, %rax + LONG $0x00000bba; BYTE $0x00 // movl $11, %edx + LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax + LONG $0x0136820f; WORD $0x0000 // jb LBB1_49, $310(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0ce8c148 // shrq $12, %rax + LONG $0x00000cba; BYTE $0x00 // movl $12, %edx + LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax + LONG $0x011e820f; WORD $0x0000 // jb LBB1_49, $286(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0de8c148 // shrq $13, %rax + LONG $0x00000dba; BYTE $0x00 // movl $13, %edx + LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax + LONG $0x0106820f; WORD $0x0000 // jb LBB1_49, $262(%rip) + LONG $0x00000eba; BYTE $0x00 // movl $14, %edx + QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00ee820f; WORD $0x0000 // jb LBB1_49, $238(%rip) + LONG $0x00000fba; BYTE $0x00 // movl $15, %edx + QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00d6820f; WORD $0x0000 // jb LBB1_49, $214(%rip) + QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax + WORD $0xd231 // xorl %edx, %edx + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + WORD $0x920f; BYTE $0xc2 // setb %dl + WORD $0xf283; BYTE $0x11 // xorl $17, %edx + LONG $0x0000bce9; BYTE $0x00 // jmp LBB1_49, $188(%rip) + +LBB1_8: + WORD $0xd088 // movb %dl, %al + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + WORD $0xff41; BYTE $0xc2 // incl %r10d + QUAD $0x0001ffffffe0bc49; WORD $0x0000 // movabsq $8589934560, %r12 + QUAD $0x540be41f24848d49 // leaq $1410065439(%r12), %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0xff4b870f; WORD $0xffff // ja LBB1_34, $-181(%rip) + +LBB1_40: + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + LONG $0x0aff8348 // cmpq $10, %rdi + LONG $0x008a820f; WORD $0x0000 // jb LBB1_49, $138(%rip) + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + LONG $0x64ff8348 // cmpq $100, %rdi + LONG $0x007b820f; WORD $0x0000 // jb LBB1_49, $123(%rip) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi + LONG $0x0069820f; WORD $0x0000 // jb LBB1_49, $105(%rip) + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi + LONG $0x0057820f; WORD $0x0000 // jb LBB1_49, $87(%rip) + LONG $0x000005ba; BYTE $0x00 // movl $5, %edx + LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi + LONG $0x0045820f; WORD $0x0000 // jb LBB1_49, $69(%rip) + LONG $0x000006ba; BYTE $0x00 // movl $6, %edx + LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi + LONG $0x0033820f; WORD $0x0000 // jb LBB1_49, $51(%rip) + LONG $0x000007ba; BYTE $0x00 // movl $7, %edx + LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi + LONG $0x0021820f; WORD $0x0000 // jb LBB1_49, $33(%rip) + LONG $0x000008ba; BYTE $0x00 // movl $8, %edx + LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi + LONG $0x000f820f; WORD $0x0000 // jb LBB1_49, $15(%rip) + LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + WORD $0xda83; BYTE $0x00 // sbbl $0, %edx + +LBB1_49: + LONG $0x12348d46 // leal (%rdx,%r10), %r14d + LONG $0x12048d42 // leal (%rdx,%r10), %eax + WORD $0xc083; BYTE $0xea // addl $-22, %eax + WORD $0xf883; BYTE $0xe4 // cmpl $-28, %eax + LONG $0x00a4870f; WORD $0x0000 // ja LBB1_62, $164(%rip) + LONG $0x01678d4d // leaq $1(%r15), %r12 + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0x00772ae8; BYTE $0x00 // callq _format_significand, $30506(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + WORD $0x294c; BYTE $0xd0 // subq %r10, %rax + WORD $0x294c; BYTE $0xe8 // subq %r13, %rax + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_51: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x30ff7b80 // cmpb $48, $-1(%rbx) + LONG $0xff5b8d48 // leaq $-1(%rbx), %rbx + LONG $0xffef840f; WORD $0xffff // je LBB1_51, $-17(%rip) + LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx + WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x00088c0f; WORD $0x0000 // jl LBB1_54, $8(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x2404c641; BYTE $0x2e // movb $46, (%r12) + +LBB1_54: + WORD $0x03c6; BYTE $0x65 // movb $101, (%rbx) + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x011d8e0f; WORD $0x0000 // jle LBB1_55, $285(%rip) + WORD $0xff41; BYTE $0xce // decl %r14d + LONG $0x2b0143c6 // movb $43, $1(%rbx) + WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0x011f820f; WORD $0x0000 // jb LBB1_59, $287(%rip) + +LBB1_58: + WORD $0xc189 // movl %eax, %ecx + LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx + LONG $0xd1af0f48 // imulq %rcx, %rdx + LONG $0x23eac148 // shrq $35, %rdx + WORD $0x0c8d; BYTE $0x12 // leal (%rdx,%rdx), %ecx + WORD $0x0c8d; BYTE $0x89 // leal (%rcx,%rcx,4), %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0x980d8d48; WORD $0x00ae; BYTE $0x00 // leaq $44696(%rip), %rcx /* _Digits(%rip) */ + LONG $0x510cb70f // movzwl (%rcx,%rdx,2), %ecx + LONG $0x024b8966 // movw %cx, $2(%rbx) + WORD $0x300c // orb $48, %al + WORD $0x4388; BYTE $0x04 // movb %al, $4(%rbx) + LONG $0x05c38348 // addq $5, %rbx + LONG $0x000663e9; BYTE $0x00 // jmp LBB1_122, $1635(%rip) + +LBB1_62: + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0105880f; WORD $0x0000 // js LBB1_63, $261(%rip) + WORD $0x8945; BYTE $0xf6 // movl %r14d, %r14d + LONG $0x371c8d4b // leaq (%r15,%r14), %rbx + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x00068ae8; BYTE $0x00 // callq _format_integer, $1674(%rip) + WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax + LONG $0x0151830f; WORD $0x0000 // jae LBB1_103, $337(%rip) + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + WORD $0x014d; BYTE $0xd5 // addq %r10, %r13 + WORD $0x014d; BYTE $0xf5 // addq %r14, %r13 + WORD $0x2949; BYTE $0xc5 // subq %rax, %r13 + LONG $0x08fd8349 // cmpq $8, %r13 + LONG $0x01ee830f; WORD $0x0000 // jae LBB1_105, $494(%rip) + +LBB1_120: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + LONG $0x000302e9; BYTE $0x00 // jmp LBB1_121, $770(%rip) + +LBB1_11: + WORD $0xd348; BYTE $0xef // shrq %cl, %rdi + QUAD $0x0001ffffffe0b848; WORD $0x0000 // movabsq $8589934560, %rax + LONG $0xe41f0548; WORD $0x540b // addq $1410065439, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x012d860f; WORD $0x0000 // jbe LBB1_17, $301(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0be8c148 // shrq $11, %rax + LONG $0x00000bba; BYTE $0x00 // movl $11, %edx + LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax + LONG $0x019f820f; WORD $0x0000 // jb LBB1_27, $415(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0ce8c148 // shrq $12, %rax + LONG $0x00000cba; BYTE $0x00 // movl $12, %edx + LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax + LONG $0x0187820f; WORD $0x0000 // jb LBB1_27, $391(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x0de8c148 // shrq $13, %rax + LONG $0x00000dba; BYTE $0x00 // movl $13, %edx + LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax + LONG $0x016f820f; WORD $0x0000 // jb LBB1_27, $367(%rip) + LONG $0x00000eba; BYTE $0x00 // movl $14, %edx + QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x0157820f; WORD $0x0000 // jb LBB1_27, $343(%rip) + QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x000010ba; BYTE $0x00 // movl $16, %edx + +LBB1_26: + WORD $0xda83; BYTE $0x00 // sbbl $0, %edx + LONG $0x00013de9; BYTE $0x00 // jmp LBB1_27, $317(%rip) + +LBB1_55: + LONG $0x2d0143c6 // movb $45, $1(%rbx) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x2944; BYTE $0xf0 // subl %r14d, %eax + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0xfee1830f; WORD $0xffff // jae LBB1_58, $-287(%rip) + +LBB1_59: + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x0087820f; WORD $0x0000 // jb LBB1_61, $135(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0x850d8d48; WORD $0x00ad; BYTE $0x00 // leaq $44421(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x02438966 // movw %ax, $2(%rbx) + LONG $0x04c38348 // addq $4, %rbx + LONG $0x000555e9; BYTE $0x00 // jmp LBB1_122, $1365(%rip) + +LBB1_63: + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x02fa8f0f; WORD $0x0000 // jg LBB1_76, $762(%rip) + LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) + LONG $0x02c78349 // addq $2, %r15 + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x02e7890f; WORD $0x0000 // jns LBB1_76, $743(%rip) + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0xf741; BYTE $0xd0 // notl %r8d + WORD $0x2945; BYTE $0xd0 // subl %r10d, %r8d + WORD $0xc031 // xorl %eax, %eax + LONG $0x1ff88341 // cmpl $31, %r8d + LONG $0x02bb820f; WORD $0x0000 // jb LBB1_74, $699(%rip) + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x214c; BYTE $0xe0 // andq %r12, %rax + LONG $0xe0488d48 // leaq $-32(%rax), %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0x05eec148 // shrq $5, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8941; BYTE $0xf1 // movl %esi, %r9d + LONG $0x03e18341 // andl $3, %r9d + LONG $0x60f98348 // cmpq $96, %rcx + LONG $0x01f7830f; WORD $0x0000 // jae LBB1_68, $503(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x000243e9; BYTE $0x00 // jmp LBB1_70, $579(%rip) + +LBB1_103: + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x0004e8e9; BYTE $0x00 // jmp LBB1_122, $1256(%rip) + +LBB1_61: + WORD $0x3004 // addb $48, %al + WORD $0x4388; BYTE $0x02 // movb %al, $2(%rbx) + LONG $0x03c38348 // addq $3, %rbx + LONG $0x0004dae9; BYTE $0x00 // jmp LBB1_122, $1242(%rip) + +LBB1_17: + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + LONG $0x0aff8348 // cmpq $10, %rdi + LONG $0x007b820f; WORD $0x0000 // jb LBB1_27, $123(%rip) + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + LONG $0x64ff8348 // cmpq $100, %rdi + LONG $0x006c820f; WORD $0x0000 // jb LBB1_27, $108(%rip) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi + LONG $0x005a820f; WORD $0x0000 // jb LBB1_27, $90(%rip) + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi + LONG $0x0048820f; WORD $0x0000 // jb LBB1_27, $72(%rip) + LONG $0x000005ba; BYTE $0x00 // movl $5, %edx + LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi + LONG $0x0036820f; WORD $0x0000 // jb LBB1_27, $54(%rip) + LONG $0x000006ba; BYTE $0x00 // movl $6, %edx + LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi + LONG $0x0024820f; WORD $0x0000 // jb LBB1_27, $36(%rip) + LONG $0x000007ba; BYTE $0x00 // movl $7, %edx + LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi + LONG $0x0012820f; WORD $0x0000 // jb LBB1_27, $18(%rip) + LONG $0x000008ba; BYTE $0x00 // movl $8, %edx + LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi + LONG $0x0478830f; WORD $0x0000 // jae LBB1_25, $1144(%rip) + +LBB1_27: + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x000487e8; BYTE $0x00 // callq _format_integer, $1159(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + WORD $0x5d2b; BYTE $0xd0 // subl $-48(%rbp), %ebx + LONG $0x000440e9; BYTE $0x00 // jmp LBB1_123, $1088(%rip) + +LBB1_105: + LONG $0x20fd8349 // cmpq $32, %r13 + LONG $0x0007830f; WORD $0x0000 // jae LBB1_110, $7(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x0000c6e9; BYTE $0x00 // jmp LBB1_107, $198(%rip) + +LBB1_110: + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + LONG $0xe0e18348 // andq $-32, %rcx + LONG $0xe0798d48 // leaq $-32(%rcx), %rdi + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0x05eec148 // shrq $5, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xf289 // movl %esi, %edx + WORD $0xe283; BYTE $0x03 // andl $3, %edx + LONG $0x60ff8348 // cmpq $96, %rdi + LONG $0x0007830f; WORD $0x0000 // jae LBB1_112, $7(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x00004de9; BYTE $0x00 // jmp LBB1_114, $77(%rip) + +LBB1_112: + LONG $0xfce68348 // andq $-4, %rsi + WORD $0xff31 // xorl %edi, %edi + QUAD $0xfffff902056f0f66 // movdqa $-1790(%rip), %xmm0 /* LCPI1_0(%rip) */ + WORD $0x9090 // .p2align 4, 0x90 + +LBB1_113: + LONG $0x047f0ff3; BYTE $0x38 // movdqu %xmm0, (%rax,%rdi) + LONG $0x447f0ff3; WORD $0x1038 // movdqu %xmm0, $16(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x2038 // movdqu %xmm0, $32(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x3038 // movdqu %xmm0, $48(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x4038 // movdqu %xmm0, $64(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x5038 // movdqu %xmm0, $80(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x6038 // movdqu %xmm0, $96(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x7038 // movdqu %xmm0, $112(%rax,%rdi) + LONG $0x80ef8348 // subq $-128, %rdi + LONG $0xfcc68348 // addq $-4, %rsi + LONG $0xffc3850f; WORD $0xffff // jne LBB1_113, $-61(%rip) + +LBB1_114: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0032840f; WORD $0x0000 // je LBB1_117, $50(%rip) + LONG $0x07348d48 // leaq (%rdi,%rax), %rsi + LONG $0x10c68348 // addq $16, %rsi + LONG $0x05e2c148 // shlq $5, %rdx + WORD $0xff31 // xorl %edi, %edi + QUAD $0xfffff8a4056f0f66 // movdqa $-1884(%rip), %xmm0 /* LCPI1_0(%rip) */ + LONG $0x90909090 // .p2align 4, 0x90 + +LBB1_116: + LONG $0x447f0ff3; WORD $0xf03e // movdqu %xmm0, $-16(%rsi,%rdi) + LONG $0x047f0ff3; BYTE $0x3e // movdqu %xmm0, (%rsi,%rdi) + LONG $0x20c78348 // addq $32, %rdi + WORD $0x3948; BYTE $0xfa // cmpq %rdi, %rdx + LONG $0xffe8850f; WORD $0xffff // jne LBB1_116, $-24(%rip) + +LBB1_117: + WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 + LONG $0x0370840f; WORD $0x0000 // je LBB1_122, $880(%rip) + LONG $0x18c5f641 // testb $24, %r13b + LONG $0x0059840f; WORD $0x0000 // je LBB1_119, $89(%rip) + +LBB1_107: + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + LONG $0xf8e68348 // andq $-8, %rsi + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x0148; BYTE $0xf2 // addq %rsi, %rdx + QUAD $0x303030303030bf48; WORD $0x3030 // movabsq $3472328296227680304, %rdi + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB1_108: + LONG $0x083c8948 // movq %rdi, (%rax,%rcx) + LONG $0x08c18348 // addq $8, %rcx + WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi + LONG $0xffef850f; WORD $0xffff // jne LBB1_108, $-17(%rip) + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0x0327840f; WORD $0x0000 // je LBB1_122, $807(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB1_121: + WORD $0x02c6; BYTE $0x30 // movb $48, (%rdx) + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3948; BYTE $0xda // cmpq %rbx, %rdx + LONG $0xfff1820f; WORD $0xffff // jb LBB1_121, $-15(%rip) + LONG $0x00030de9; BYTE $0x00 // jmp LBB1_122, $781(%rip) + +LBB1_119: + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0xfffcdae9; BYTE $0xff // jmp LBB1_120, $-806(%rip) + +LBB1_68: + LONG $0xfce68348 // andq $-4, %rsi + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x2a1c8d4b // leaq (%r10,%r13), %rbx + LONG $0x72c38348 // addq $114, %rbx + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0xfffff7fa056f0f66 // movdqa $-2054(%rip), %xmm0 /* LCPI1_0(%rip) */ + +LBB1_69: + LONG $0x447f0ff3; WORD $0x900b // movdqu %xmm0, $-112(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xa00b // movdqu %xmm0, $-96(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xb00b // movdqu %xmm0, $-80(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xc00b // movdqu %xmm0, $-64(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xd00b // movdqu %xmm0, $-48(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xe00b // movdqu %xmm0, $-32(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xf00b // movdqu %xmm0, $-16(%rbx,%rcx) + LONG $0x047f0ff3; BYTE $0x0b // movdqu %xmm0, (%rbx,%rcx) + LONG $0x80e98348 // subq $-128, %rcx + LONG $0xfcc68348 // addq $-4, %rsi + LONG $0xffc3850f; WORD $0xffff // jne LBB1_69, $-61(%rip) + +LBB1_70: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0030840f; WORD $0x0000 // je LBB1_73, $48(%rip) + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x12c18348 // addq $18, %rcx + LONG $0x05e1c149 // shlq $5, %r9 + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff79c056f0f66 // movdqa $-2148(%rip), %xmm0 /* LCPI1_0(%rip) */ + +LBB1_72: + LONG $0x447f0ff3; WORD $0xf031 // movdqu %xmm0, $-16(%rcx,%rsi) + LONG $0x047f0ff3; BYTE $0x31 // movdqu %xmm0, (%rcx,%rsi) + LONG $0x20c68348 // addq $32, %rsi + WORD $0x3949; BYTE $0xf1 // cmpq %rsi, %r9 + LONG $0xffe8850f; WORD $0xffff // jne LBB1_72, $-24(%rip) + +LBB1_73: + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0017840f; WORD $0x0000 // je LBB1_76, $23(%rip) + +LBB1_74: + WORD $0x0144; BYTE $0xf0 // addl %r14d, %eax + WORD $0xd8f7 // negl %eax + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_75: + LONG $0x3007c641 // movb $48, (%r15) + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xc8ff // decl %eax + LONG $0xfff1850f; WORD $0xffff // jne LBB1_75, $-15(%rip) + +LBB1_76: + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x007279e8; BYTE $0x00 // callq _format_significand, $29305(%rip) + WORD $0xc389 // movl %eax, %ebx + WORD $0x2844; BYTE $0xfb // subb %r15b, %bl + WORD $0x2844; BYTE $0xf3 // subb %r14b, %bl + LONG $0x3e2c8d47 // leal (%r14,%r15), %r13d + WORD $0x2941; BYTE $0xc5 // subl %eax, %r13d + LONG $0xff458d45 // leal $-1(%r13), %r8d + LONG $0xfe7d8d41 // leal $-2(%r13), %edi + WORD $0xc931 // xorl %ecx, %ecx + + // .p2align 4, 0x90 +LBB1_77: + WORD $0xda89 // movl %ebx, %edx + WORD $0x5a8d; BYTE $0x03 // leal $3(%rdx), %ebx + WORD $0xc7ff // incl %edi + LONG $0xff087c80; BYTE $0x30 // cmpb $48, $-1(%rax,%rcx) + LONG $0xff498d48 // leaq $-1(%rcx), %rcx + LONG $0xffea840f; WORD $0xffff // je LBB1_77, $-22(%rip) + LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x02078e0f; WORD $0x0000 // jle LBB1_122, $519(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xfe // subl %r15d, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0xc6ff // incl %esi + WORD $0x3941; BYTE $0xf6 // cmpl %esi, %r14d + LONG $0x00308d0f; WORD $0x0000 // jge LBB1_80, $48(%rip) + WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d + WORD $0x2945; BYTE $0xf1 // subl %r14d, %r9d + WORD $0x2945; BYTE $0xf9 // subl %r15d, %r9d + WORD $0xff41; BYTE $0xc1 // incl %r9d + LONG $0x093c8d49 // leaq (%r9,%rcx), %rdi + WORD $0xff85 // testl %edi, %edi + LONG $0x00e48e0f; WORD $0x0000 // jle LBB1_99, $228(%rip) + WORD $0x8941; BYTE $0xf8 // movl %edi, %r8d + LONG $0xff588d49 // leaq $-1(%r8), %rbx + LONG $0x03fb8348 // cmpq $3, %rbx + LONG $0x0069830f; WORD $0x0000 // jae LBB1_100, $105(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x000090e9; BYTE $0x00 // jmp LBB1_96, $144(%rip) + +LBB1_80: + WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d + WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x01b68e0f; WORD $0x0000 // jle LBB1_122, $438(%rip) + WORD $0x0145; BYTE $0xfe // addl %r15d, %r14d + WORD $0x2941; BYTE $0xc6 // subl %eax, %r14d + LONG $0xfec68341 // addl $-2, %r14d + WORD $0x2949; BYTE $0xce // subq %rcx, %r14 + WORD $0xd231 // xorl %edx, %edx + LONG $0x1ffe8341 // cmpl $31, %r14d + LONG $0x018c820f; WORD $0x0000 // jb LBB1_91, $396(%rip) + LONG $0xfec58341 // addl $-2, %r13d + WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 + WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x214d; BYTE $0xc4 // andq %r8, %r12 + WORD $0x8941; BYTE $0xf9 // movl %edi, %r9d + WORD $0xff49; BYTE $0xc1 // incq %r9 + LONG $0xe0e18349 // andq $-32, %r9 + LONG $0x24548d49; BYTE $0xe0 // leaq $-32(%r12), %rdx + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + LONG $0x05eac149 // shrq $5, %r10 + WORD $0xff49; BYTE $0xc2 // incq %r10 + LONG $0x60fa8348 // cmpq $96, %rdx + LONG $0x0086830f; WORD $0x0000 // jae LBB1_84, $134(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x0000e4e9; BYTE $0x00 // jmp LBB1_86, $228(%rip) + +LBB1_100: + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + LONG $0xfce18341 // andl $-4, %r9d + WORD $0xf749; BYTE $0xd9 // negq %r9 + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB1_101: + LONG $0x183c8d48 // leaq (%rax,%rbx), %rdi + LONG $0xfd39748b // movl $-3(%rcx,%rdi), %esi + LONG $0xfe397489 // movl %esi, $-2(%rcx,%rdi) + LONG $0xfcc38348 // addq $-4, %rbx + WORD $0x3949; BYTE $0xd9 // cmpq %rbx, %r9 + LONG $0xffe7850f; WORD $0xffff // jne LBB1_101, $-25(%rip) + WORD $0xf748; BYTE $0xdb // negq %rbx + +LBB1_96: + LONG $0x03c0f641 // testb $3, %r8b + LONG $0x0032840f; WORD $0x0000 // je LBB1_99, $50(%rip) + LONG $0xc2b60f44 // movzbl %dl, %r8d + LONG $0x03e08341 // andl $3, %r8d + WORD $0xf749; BYTE $0xd8 // negq %r8 + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x2948; BYTE $0xde // subq %rbx, %rsi + WORD $0xff31 // xorl %edi, %edi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB1_98: + LONG $0x3e1c8d48 // leaq (%rsi,%rdi), %rbx + LONG $0x1914b60f // movzbl (%rcx,%rbx), %edx + LONG $0x01195488 // movb %dl, $1(%rcx,%rbx) + WORD $0xff48; BYTE $0xcf // decq %rdi + WORD $0x3949; BYTE $0xf8 // cmpq %rdi, %r8 + LONG $0xffe8850f; WORD $0xffff // jne LBB1_98, $-24(%rip) + +LBB1_99: + WORD $0x8944; BYTE $0xf2 // movl %r14d, %edx + LONG $0x1704c641; BYTE $0x2e // movb $46, (%r15,%rdx) + LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx + LONG $0x02c38348 // addq $2, %rbx + LONG $0x0000e4e9; BYTE $0x00 // jmp LBB1_122, $228(%rip) + +LBB1_84: + WORD $0x8944; BYTE $0xef // movl %r13d, %edi + WORD $0xff48; BYTE $0xc7 // incq %rdi + LONG $0xe0e78348 // andq $-32, %rdi + LONG $0xe0c78348 // addq $-32, %rdi + LONG $0x05efc148 // shrq $5, %rdi + WORD $0xff48; BYTE $0xc7 // incq %rdi + LONG $0xfce78348 // andq $-4, %rdi + WORD $0xdb31 // xorl %ebx, %ebx + QUAD $0xfffff5d0056f0f66 // movdqa $-2608(%rip), %xmm0 /* LCPI1_0(%rip) */ + +LBB1_85: + LONG $0x18148d48 // leaq (%rax,%rbx), %rdx + LONG $0x447f0ff3; WORD $0x0111 // movdqu %xmm0, $1(%rcx,%rdx) + LONG $0x447f0ff3; WORD $0x1111 // movdqu %xmm0, $17(%rcx,%rdx) + LONG $0x447f0ff3; WORD $0x2111 // movdqu %xmm0, $33(%rcx,%rdx) + LONG $0x447f0ff3; WORD $0x3111 // movdqu %xmm0, $49(%rcx,%rdx) + LONG $0x447f0ff3; WORD $0x4111 // movdqu %xmm0, $65(%rcx,%rdx) + LONG $0x447f0ff3; WORD $0x5111 // movdqu %xmm0, $81(%rcx,%rdx) + LONG $0x447f0ff3; WORD $0x6111 // movdqu %xmm0, $97(%rcx,%rdx) + LONG $0x447f0ff3; WORD $0x7111 // movdqu %xmm0, $113(%rcx,%rdx) + LONG $0x80eb8348 // subq $-128, %rbx + LONG $0xfcc78348 // addq $-4, %rdi + LONG $0xffbe850f; WORD $0xffff // jne LBB1_85, $-66(%rip) + +LBB1_86: + WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 + LONG $0x03c2f641 // testb $3, %r10b + LONG $0x004a840f; WORD $0x0000 // je LBB1_89, $74(%rip) + WORD $0xfe41; BYTE $0xc5 // incb %r13b + LONG $0x60e58041 // andb $96, %r13b + LONG $0xe0c58041 // addb $-32, %r13b + LONG $0x05edc041 // shrb $5, %r13b + WORD $0xfe41; BYTE $0xc5 // incb %r13b + LONG $0xd5b60f41 // movzbl %r13b, %edx + WORD $0xe283; BYTE $0x03 // andl $3, %edx + LONG $0x05e2c148 // shlq $5, %rdx + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0x11c08348 // addq $17, %rax + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff553056f0f66 // movdqa $-2733(%rip), %xmm0 /* LCPI1_0(%rip) */ + +LBB1_88: + LONG $0x303c8d48 // leaq (%rax,%rsi), %rdi + LONG $0x447f0ff3; WORD $0xf039 // movdqu %xmm0, $-16(%rcx,%rdi) + LONG $0x047f0ff3; BYTE $0x39 // movdqu %xmm0, (%rcx,%rdi) + LONG $0x20c68348 // addq $32, %rsi + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0xffe4850f; WORD $0xffff // jne LBB1_88, $-28(%rip) + +LBB1_89: + LONG $0x091c8d4a // leaq (%rcx,%r9), %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x394d; BYTE $0xe0 // cmpq %r12, %r8 + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + LONG $0x0014840f; WORD $0x0000 // je LBB1_122, $20(%rip) + WORD $0x8944; BYTE $0xe2 // movl %r12d, %edx + + // .p2align 4, 0x90 +LBB1_91: + WORD $0x03c6; BYTE $0x30 // movb $48, (%rbx) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xc2ff // incl %edx + WORD $0x3944; BYTE $0xda // cmpl %r11d, %edx + LONG $0xffef8c0f; WORD $0xffff // jl LBB1_91, $-17(%rip) + +LBB1_122: + WORD $0x2944; BYTE $0xd3 // subl %r10d, %ebx + +LBB1_123: + WORD $0xd889 // movl %ebx, %eax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB1_1: + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xffffe8e9; BYTE $0xff // jmp LBB1_123, $-24(%rip) + +LBB1_5: + LONG $0xfffbcebe; BYTE $0xff // movl $-1074, %esi + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0xfff594e9; BYTE $0xff // jmp LBB1_6, $-2668(%rip) + +LBB1_25: + LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + LONG $0xfffa32e9; BYTE $0xff // jmp LBB1_26, $-1486(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_format_integer: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x20e8c148 // shrq $32, %rax + LONG $0x0016850f; WORD $0x0000 // jne LBB2_2, $22(%rip) + WORD $0x894d; BYTE $0xc3 // movq %r8, %r11 + LONG $0x2710ff81; WORD $0x0000 // cmpl $10000, %edi + LONG $0x00c3830f; WORD $0x0000 // jae LBB2_5, $195(%rip) + +LBB2_4: + WORD $0xfa89 // movl %edi, %edx + LONG $0x00011ae9; BYTE $0x00 // jmp LBB2_7, $282(%rip) + +LBB2_2: + QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0x1f00ca69; WORD $0xfa0a // imull $-100000000, %edx, %ecx + WORD $0xf901 // addl %edi, %ecx + LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xc1af0f49 // imulq %r9, %rax + LONG $0x2de8c148 // shrq $45, %rax + LONG $0x2710f869; WORD $0x0000 // imull $10000, %eax, %edi + WORD $0xf929 // subl %edi, %ecx + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xf9af0f49 // imulq %r9, %rdi + LONG $0x2defc148 // shrq $45, %rdi + LONG $0x2710ff69; WORD $0x0000 // imull $10000, %edi, %edi + WORD $0xf829 // subl %edi, %eax + WORD $0xb70f; BYTE $0xf9 // movzwl %cx, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull $5243, %edi, %r9d + LONG $0x11e9c141 // shrl $17, %r9d + LONG $0x64f96b41 // imull $100, %r9d, %edi + WORD $0xf929 // subl %edi, %ecx + LONG $0xd1b70f44 // movzwl %cx, %r10d + WORD $0xb70f; BYTE $0xf8 // movzwl %ax, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x147bff69; WORD $0x0000 // imull $5243, %edi, %edi + WORD $0xefc1; BYTE $0x11 // shrl $17, %edi + WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0xd8b70f44 // movzwl %ax, %r11d + LONG $0x300d8d48; WORD $0x00a7; BYTE $0x00 // leaq $42800(%rip), %rcx /* _Digits(%rip) */ + LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax + LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) + LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax + LONG $0x40894166; BYTE $0xfc // movw %ax, $-4(%r8) + LONG $0x04b70f42; BYTE $0x59 // movzwl (%rcx,%r11,2), %eax + LONG $0x40894166; BYTE $0xfa // movw %ax, $-6(%r8) + LONG $0xf8588d4d // leaq $-8(%r8), %r11 + LONG $0x790cb70f // movzwl (%rcx,%rdi,2), %ecx + LONG $0x48894166; BYTE $0xf8 // movw %cx, $-8(%r8) + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0x2710ff81; WORD $0x0000 // cmpl $10000, %edi + LONG $0xff3d820f; WORD $0xffff // jb LBB2_4, $-195(%rip) + +LBB2_5: + LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d + LONG $0xe9158d4c; WORD $0x00a6; BYTE $0x00 // leaq $42729(%rip), %r10 /* _Digits(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB2_6: + WORD $0xfa89 // movl %edi, %edx + LONG $0xd1af0f49 // imulq %r9, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0xd8f0ca69; WORD $0xffff // imull $-10000, %edx, %ecx + WORD $0xf901 // addl %edi, %ecx + LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx + WORD $0xd929 // subl %ebx, %ecx + LONG $0x0cb70f41; BYTE $0x4a // movzwl (%r10,%rcx,2), %ecx + LONG $0x4b894166; BYTE $0xfe // movw %cx, $-2(%r11) + LONG $0x04b70f41; BYTE $0x42 // movzwl (%r10,%rax,2), %eax + LONG $0x43894166; BYTE $0xfc // movw %ax, $-4(%r11) + LONG $0xfcc38349 // addq $-4, %r11 + LONG $0xe0ffff81; WORD $0x05f5 // cmpl $99999999, %edi + WORD $0xd789 // movl %edx, %edi + LONG $0xffb8870f; WORD $0xffff // ja LBB2_6, $-72(%rip) + +LBB2_7: + WORD $0xfa83; BYTE $0x64 // cmpl $100, %edx + LONG $0x002d820f; WORD $0x0000 // jb LBB2_9, $45(%rip) + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx + WORD $0xca29 // subl %ecx, %edx + WORD $0xb70f; BYTE $0xca // movzwl %dx, %ecx + LONG $0x71158d48; WORD $0x00a6; BYTE $0x00 // leaq $42609(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x4b894166; BYTE $0xfe // movw %cx, $-2(%r11) + LONG $0xfec38349 // addq $-2, %r11 + WORD $0xc289 // movl %eax, %edx + +LBB2_9: + WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx + LONG $0x0018820f; WORD $0x0000 // jb LBB2_11, $24(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x500d8d48; WORD $0x00a6; BYTE $0x00 // leaq $42576(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x43894166; BYTE $0xfe // movw %ax, $-2(%r11) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB2_11: + WORD $0xc280; BYTE $0x30 // addb $48, %dl + WORD $0x1688 // movb %dl, (%rsi) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_i64toa: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x00b1880f; WORD $0x0000 // js LBB3_12, $177(%rip) + LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi + LONG $0x00b6870f; WORD $0x0000 // ja LBB3_9, $182(%rip) + WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x00148d48 // leaq (%rax,%rax), %rdx + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xf189 // movl %esi, %ecx + WORD $0xc129 // subl %eax, %ecx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi + LONG $0x0017820f; WORD $0x0000 // jb LBB3_4, $23(%rip) + LONG $0xe3058d48; WORD $0x00a5; BYTE $0x00 // leaq $42467(%rip), %rax /* _Digits(%rip) */ + LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x00000be9; BYTE $0x00 // jmp LBB3_5, $11(%rip) + +LBB3_4: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x0046820f; WORD $0x0000 // jb LBB3_6, $70(%rip) + +LBB3_5: + WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx + LONG $0x01ca8348 // orq $1, %rdx + LONG $0xba358d48; WORD $0x00a5; BYTE $0x00 // leaq $42426(%rip), %rsi /* _Digits(%rip) */ + LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB3_7: + LONG $0xa8158d48; WORD $0x00a5; BYTE $0x00 // leaq $42408(%rip), %rdx /* _Digits(%rip) */ + LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB3_8: + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + LONG $0x01c98348 // orq $1, %rcx + LONG $0x8f158d48; WORD $0x00a5; BYTE $0x00 // leaq $42383(%rip), %rdx /* _Digits(%rip) */ + LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx + WORD $0xc289 // movl %eax, %edx + WORD $0xc0ff // incl %eax + WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB3_6: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0xffc8830f; WORD $0xffff // jae LBB3_7, $-56(%rip) + LONG $0xffffd5e9; BYTE $0xff // jmp LBB3_8, $-43(%rip) + +LBB3_12: + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xf748; BYTE $0xde // negq %rsi + LONG $0x000044e8; BYTE $0x00 // callq _u64toa, $68(%rip) + WORD $0xc0ff // incl %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB3_9: + LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi + LONG $0x0006870f; WORD $0x0000 // ja LBB3_10, $6(%rip) + BYTE $0x5d // popq %rbp + LONG $0x00011de9; BYTE $0x00 // jmp _u32toa_medium, $285(%rip) + +LBB3_10: + QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0006870f; WORD $0x0000 // ja LBB3_11, $6(%rip) + BYTE $0x5d // popq %rbp + LONG $0x000254e9; BYTE $0x00 // jmp _u64toa_large_sse2, $596(%rip) + +LBB3_11: + BYTE $0x5d // popq %rbp + LONG $0x0003bee9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $958(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_u64toa: + LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi + LONG $0x00a8870f; WORD $0x0000 // ja LBB4_8, $168(%rip) + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x00148d48 // leaq (%rax,%rax), %rdx + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xf189 // movl %esi, %ecx + WORD $0xc129 // subl %eax, %ecx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi + LONG $0x0017820f; WORD $0x0000 // jb LBB4_3, $23(%rip) + LONG $0xdc058d48; WORD $0x00a4; BYTE $0x00 // leaq $42204(%rip), %rax /* _Digits(%rip) */ + LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x00000be9; BYTE $0x00 // jmp LBB4_4, $11(%rip) + +LBB4_3: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x0046820f; WORD $0x0000 // jb LBB4_5, $70(%rip) + +LBB4_4: + WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx + LONG $0x01ca8348 // orq $1, %rdx + LONG $0xb3358d48; WORD $0x00a4; BYTE $0x00 // leaq $42163(%rip), %rsi /* _Digits(%rip) */ + LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB4_6: + LONG $0xa1158d48; WORD $0x00a4; BYTE $0x00 // leaq $42145(%rip), %rdx /* _Digits(%rip) */ + LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB4_7: + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + LONG $0x01c98348 // orq $1, %rcx + LONG $0x88158d48; WORD $0x00a4; BYTE $0x00 // leaq $42120(%rip), %rdx /* _Digits(%rip) */ + LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx + WORD $0xc289 // movl %eax, %edx + WORD $0xc0ff // incl %eax + WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB4_5: + WORD $0xc031 // xorl %eax, %eax + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0xffc8830f; WORD $0xffff // jae LBB4_6, $-56(%rip) + LONG $0xffffd5e9; BYTE $0xff // jmp LBB4_7, $-43(%rip) + +LBB4_8: + LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi + LONG $0x0005870f; WORD $0x0000 // ja LBB4_9, $5(%rip) + LONG $0x000029e9; BYTE $0x00 // jmp _u32toa_medium, $41(%rip) + +LBB4_9: + QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0005870f; WORD $0x0000 // ja LBB4_10, $5(%rip) + LONG $0x000161e9; BYTE $0x00 // jmp _u64toa_large_sse2, $353(%rip) + +LBB4_10: + LONG $0x0002cce9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $716(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +_u32toa_medium: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0xf089 // movl %esi, %eax + LONG $0xb71759b9; BYTE $0xd1 // movl $3518437209, %ecx + LONG $0xc8af0f48 // imulq %rax, %rcx + LONG $0x2de9c148 // shrq $45, %rcx + LONG $0x2710d169; WORD $0x0000 // imull $10000, %ecx, %edx + WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d + WORD $0x2941; BYTE $0xd0 // subl %edx, %r8d + LONG $0x83d06948; WORD $0x1bde; BYTE $0x43 // imulq $1125899907, %rax, %rdx + LONG $0x31eac148 // shrq $49, %rdx + WORD $0xe283; BYTE $0xfe // andl $-2, %edx + LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xc129 // subl %eax, %ecx + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0x9680fe81; WORD $0x0098 // cmpl $10000000, %esi + LONG $0x0017820f; WORD $0x0000 // jb LBB5_2, $23(%rip) + LONG $0xdd058d48; WORD $0x00a3; BYTE $0x00 // leaq $41949(%rip), %rax /* _Digits(%rip) */ + LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x00000ee9; BYTE $0x00 // jmp LBB5_3, $14(%rip) + +LBB5_2: + WORD $0xc031 // xorl %eax, %eax + LONG $0x4240fe81; WORD $0x000f // cmpl $1000000, %esi + LONG $0x0074820f; WORD $0x0000 // jb LBB5_4, $116(%rip) + +LBB5_3: + WORD $0xd289 // movl %edx, %edx + LONG $0x01ca8348 // orq $1, %rdx + LONG $0xb2358d48; WORD $0x00a3; BYTE $0x00 // leaq $41906(%rip), %rsi /* _Digits(%rip) */ + LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB5_5: + LONG $0xa0158d48; WORD $0x00a3; BYTE $0x00 // leaq $41888(%rip), %rdx /* _Digits(%rip) */ + LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx + WORD $0xc689 // movl %eax, %esi + WORD $0xc0ff // incl %eax + WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + +LBB5_6: + LONG $0xd0b70f41 // movzwl %r8w, %edx + WORD $0xeac1; BYTE $0x02 // shrl $2, %edx + LONG $0x147bd269; WORD $0x0000 // imull $5243, %edx, %edx + WORD $0xeac1; BYTE $0x11 // shrl $17, %edx + WORD $0xf26b; BYTE $0x64 // imull $100, %edx, %esi + WORD $0x2941; BYTE $0xf0 // subl %esi, %r8d + LONG $0xc0b70f45 // movzwl %r8w, %r8d + WORD $0xc989 // movl %ecx, %ecx + LONG $0x01c98348 // orq $1, %rcx + LONG $0x6e0d8d4c; WORD $0x00a3; BYTE $0x00 // leaq $41838(%rip), %r9 /* _Digits(%rip) */ + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xc689 // movl %eax, %esi + WORD $0x0c88; BYTE $0x37 // movb %cl, (%rdi,%rsi) + LONG $0x0cb70f41; BYTE $0x51 // movzwl (%r9,%rdx,2), %ecx + LONG $0x374c8966; BYTE $0x01 // movw %cx, $1(%rdi,%rsi) + LONG $0x0cb70f43; BYTE $0x41 // movzwl (%r9,%r8,2), %ecx + LONG $0x374c8966; BYTE $0x03 // movw %cx, $3(%rdi,%rsi) + WORD $0xc083; BYTE $0x05 // addl $5, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB5_4: + WORD $0xc031 // xorl %eax, %eax + LONG $0x86a0fe81; WORD $0x0001 // cmpl $100000, %esi + LONG $0xff96830f; WORD $0xffff // jae LBB5_5, $-106(%rip) + LONG $0xffffa3e9; BYTE $0xff // jmp LBB5_6, $-93(%rip) + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +LCPI6_0: + QUAD $0x00000000d1b71759 // .quad 3518437209 + QUAD $0x00000000d1b71759 // .quad 3518437209 + +LCPI6_1: + WORD $0x20c5 // .word 8389 + WORD $0x147b // .word 5243 + WORD $0x3334 // .word 13108 + WORD $0x8000 // .word 32768 + WORD $0x20c5 // .word 8389 + WORD $0x147b // .word 5243 + WORD $0x3334 // .word 13108 + WORD $0x8000 // .word 32768 + +LCPI6_2: + WORD $0x0080 // .word 128 + WORD $0x0800 // .word 2048 + WORD $0x2000 // .word 8192 + WORD $0x8000 // .word 32768 + WORD $0x0080 // .word 128 + WORD $0x0800 // .word 2048 + WORD $0x2000 // .word 8192 + WORD $0x8000 // .word 32768 + +LCPI6_3: + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + +LCPI6_4: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x90 +_u64toa_large_sse2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax + WORD $0xc629 // subl %eax, %esi + LONG $0xc26e0f66 // movd %edx, %xmm0 + QUAD $0xffffff840d6f0f66 // movdqa $-124(%rip), %xmm1 /* LCPI6_0(%rip) */ + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + LONG $0xd1f40f66 // pmuludq %xmm1, %xmm2 + LONG $0xd2730f66; BYTE $0x2d // psrlq $45, %xmm2 + LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax + LONG $0x6e0f4866; BYTE $0xd8 // movq %rax, %xmm3 + LONG $0xe26f0f66 // movdqa %xmm2, %xmm4 + LONG $0xe3f40f66 // pmuludq %xmm3, %xmm4 + LONG $0xc4fa0f66 // psubd %xmm4, %xmm0 + LONG $0xd0610f66 // punpcklwd %xmm0, %xmm2 + LONG $0xf2730f66; BYTE $0x02 // psllq $2, %xmm2 + LONG $0xc2700ff2; BYTE $0x50 // pshuflw $80, %xmm2, %xmm0 + LONG $0xc0700f66; BYTE $0x50 // pshufd $80, %xmm0, %xmm0 + QUAD $0xffffff56156f0f66 // movdqa $-170(%rip), %xmm2 /* LCPI6_1(%rip) */ + LONG $0xc2e40f66 // pmulhuw %xmm2, %xmm0 + QUAD $0xffffff5a256f0f66 // movdqa $-166(%rip), %xmm4 /* LCPI6_2(%rip) */ + LONG $0xc4e40f66 // pmulhuw %xmm4, %xmm0 + QUAD $0xffffff5e2d6f0f66 // movdqa $-162(%rip), %xmm5 /* LCPI6_3(%rip) */ + LONG $0xf06f0f66 // movdqa %xmm0, %xmm6 + LONG $0xf5d50f66 // pmullw %xmm5, %xmm6 + LONG $0xf6730f66; BYTE $0x10 // psllq $16, %xmm6 + LONG $0xc6f90f66 // psubw %xmm6, %xmm0 + LONG $0xf66e0f66 // movd %esi, %xmm6 + LONG $0xcef40f66 // pmuludq %xmm6, %xmm1 + LONG $0xd1730f66; BYTE $0x2d // psrlq $45, %xmm1 + LONG $0xd9f40f66 // pmuludq %xmm1, %xmm3 + LONG $0xf3fa0f66 // psubd %xmm3, %xmm6 + LONG $0xce610f66 // punpcklwd %xmm6, %xmm1 + LONG $0xf1730f66; BYTE $0x02 // psllq $2, %xmm1 + LONG $0xc9700ff2; BYTE $0x50 // pshuflw $80, %xmm1, %xmm1 + LONG $0xc9700f66; BYTE $0x50 // pshufd $80, %xmm1, %xmm1 + LONG $0xcae40f66 // pmulhuw %xmm2, %xmm1 + LONG $0xcce40f66 // pmulhuw %xmm4, %xmm1 + LONG $0xe9d50f66 // pmullw %xmm1, %xmm5 + LONG $0xf5730f66; BYTE $0x10 // psllq $16, %xmm5 + LONG $0xcdf90f66 // psubw %xmm5, %xmm1 + LONG $0xc1670f66 // packuswb %xmm1, %xmm0 + QUAD $0xffffff140d6f0f66 // movdqa $-236(%rip), %xmm1 /* LCPI6_4(%rip) */ + LONG $0xc8fc0f66 // paddb %xmm0, %xmm1 + LONG $0xd2ef0f66 // pxor %xmm2, %xmm2 + LONG $0xd0740f66 // pcmpeqb %xmm0, %xmm2 + LONG $0xc2d70f66 // pmovmskb %xmm2, %eax + WORD $0xd0f7 // notl %eax + LONG $0x0080000d; BYTE $0x00 // orl $32768, %eax + WORD $0xbc0f; BYTE $0xc8 // bsfl %eax, %ecx + LONG $0x000010b8; BYTE $0x00 // movl $16, %eax + WORD $0xc829 // subl %ecx, %eax + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x38158d48; WORD $0x00c9; BYTE $0x00 // leaq $51512(%rip), %rdx /* _VecShiftShuffles(%rip) */ + LONG $0x00380f66; WORD $0x110c // pshufb (%rcx,%rdx), %xmm1 + LONG $0x0f7f0ff3 // movdqu %xmm1, (%rdi) + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 + +LCPI7_0: + QUAD $0x00000000d1b71759 // .quad 3518437209 + QUAD $0x00000000d1b71759 // .quad 3518437209 + +LCPI7_1: + WORD $0x20c5 // .word 8389 + WORD $0x147b // .word 5243 + WORD $0x3334 // .word 13108 + WORD $0x8000 // .word 32768 + WORD $0x20c5 // .word 8389 + WORD $0x147b // .word 5243 + WORD $0x3334 // .word 13108 + WORD $0x8000 // .word 32768 + +LCPI7_2: + WORD $0x0080 // .word 128 + WORD $0x0800 // .word 2048 + WORD $0x2000 // .word 8192 + WORD $0x8000 // .word 32768 + WORD $0x0080 // .word 128 + WORD $0x0800 // .word 2048 + WORD $0x2000 // .word 8192 + WORD $0x8000 // .word 32768 + +LCPI7_3: + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + +LCPI7_4: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x90 +_u64toa_xlarge_sse2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + QUAD $0x652fb1137857b948; WORD $0x39a5 // movabsq $4153837486827862103, %rcx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x33eac148 // shrq $51, %rdx + QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax + LONG $0xc2af0f48 // imulq %rdx, %rax + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + WORD $0xfa83; BYTE $0x09 // cmpl $9, %edx + LONG $0x000f870f; WORD $0x0000 // ja LBB7_2, $15(%rip) + WORD $0xc280; BYTE $0x30 // addb $48, %dl + WORD $0x1788 // movb %dl, (%rdi) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + LONG $0x0000a7e9; BYTE $0x00 // jmp LBB7_7, $167(%rip) + +LBB7_2: + WORD $0xfa83; BYTE $0x63 // cmpl $99, %edx + LONG $0x001a870f; WORD $0x0000 // ja LBB7_4, $26(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x1d0d8d48; WORD $0x00a1; BYTE $0x00 // leaq $41245(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx + LONG $0x000084e9; BYTE $0x00 // jmp LBB7_7, $132(%rip) + +LBB7_4: + WORD $0xd089 // movl %edx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x03e7fa81; WORD $0x0000 // cmpl $999, %edx + LONG $0x0037870f; WORD $0x0000 // ja LBB7_6, $55(%rip) + WORD $0xc083; BYTE $0x30 // addl $48, %eax + WORD $0x0788 // movb %al, (%rdi) + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x02 // shrl $2, %ecx + LONG $0x147bc969; WORD $0x0000 // imull $5243, %ecx, %ecx + WORD $0xe9c1; BYTE $0x11 // shrl $17, %ecx + WORD $0xc96b; BYTE $0x64 // imull $100, %ecx, %ecx + WORD $0xc829 // subl %ecx, %eax + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0xcd0d8d48; WORD $0x00a0; BYTE $0x00 // leaq $41165(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x01478966 // movw %ax, $1(%rdi) + LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx + LONG $0x000033e9; BYTE $0x00 // jmp LBB7_7, $51(%rip) + +LBB7_6: + WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx + WORD $0xca29 // subl %ecx, %edx + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0xac0d8d48; WORD $0x00a0; BYTE $0x00 // leaq $41132(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + LONG $0x4114b60f // movzbl (%rcx,%rax,2), %edx + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax + WORD $0x5788; BYTE $0x02 // movb %dl, $2(%rdi) + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0x0844b60f; BYTE $0x01 // movzbl $1(%rax,%rcx), %eax + WORD $0x4788; BYTE $0x03 // movb %al, $3(%rdi) + LONG $0x000004b9; BYTE $0x00 // movl $4, %ecx + +LBB7_7: + QUAD $0x77118461cefdba48; WORD $0xabcc // movabsq $-6067343680855748867, %rdx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe2 // mulq %rdx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0xc26e0f66 // movd %edx, %xmm0 + QUAD $0xfffffea80d6f0f66 // movdqa $-344(%rip), %xmm1 /* LCPI7_0(%rip) */ + LONG $0xd86f0f66 // movdqa %xmm0, %xmm3 + LONG $0xd9f40f66 // pmuludq %xmm1, %xmm3 + LONG $0xd3730f66; BYTE $0x2d // psrlq $45, %xmm3 + LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax + LONG $0x6e0f4866; BYTE $0xd0 // movq %rax, %xmm2 + LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 + LONG $0xe2f40f66 // pmuludq %xmm2, %xmm4 + LONG $0xc4fa0f66 // psubd %xmm4, %xmm0 + LONG $0xd8610f66 // punpcklwd %xmm0, %xmm3 + LONG $0xf3730f66; BYTE $0x02 // psllq $2, %xmm3 + LONG $0xc3700ff2; BYTE $0x50 // pshuflw $80, %xmm3, %xmm0 + LONG $0xc0700f66; BYTE $0x50 // pshufd $80, %xmm0, %xmm0 + QUAD $0xfffffe7a256f0f66 // movdqa $-390(%rip), %xmm4 /* LCPI7_1(%rip) */ + LONG $0xc4e40f66 // pmulhuw %xmm4, %xmm0 + QUAD $0xfffffe7e2d6f0f66 // movdqa $-386(%rip), %xmm5 /* LCPI7_2(%rip) */ + LONG $0xc5e40f66 // pmulhuw %xmm5, %xmm0 + QUAD $0xfffffe821d6f0f66 // movdqa $-382(%rip), %xmm3 /* LCPI7_3(%rip) */ + LONG $0xf06f0f66 // movdqa %xmm0, %xmm6 + LONG $0xf3d50f66 // pmullw %xmm3, %xmm6 + LONG $0xf6730f66; BYTE $0x10 // psllq $16, %xmm6 + LONG $0xc6f90f66 // psubw %xmm6, %xmm0 + LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax + WORD $0xc629 // subl %eax, %esi + LONG $0xf66e0f66 // movd %esi, %xmm6 + LONG $0xcef40f66 // pmuludq %xmm6, %xmm1 + LONG $0xd1730f66; BYTE $0x2d // psrlq $45, %xmm1 + LONG $0xd1f40f66 // pmuludq %xmm1, %xmm2 + LONG $0xf2fa0f66 // psubd %xmm2, %xmm6 + LONG $0xce610f66 // punpcklwd %xmm6, %xmm1 + LONG $0xf1730f66; BYTE $0x02 // psllq $2, %xmm1 + LONG $0xc9700ff2; BYTE $0x50 // pshuflw $80, %xmm1, %xmm1 + LONG $0xc9700f66; BYTE $0x50 // pshufd $80, %xmm1, %xmm1 + LONG $0xcce40f66 // pmulhuw %xmm4, %xmm1 + LONG $0xcde40f66 // pmulhuw %xmm5, %xmm1 + LONG $0xd9d50f66 // pmullw %xmm1, %xmm3 + LONG $0xf3730f66; BYTE $0x10 // psllq $16, %xmm3 + LONG $0xcbf90f66 // psubw %xmm3, %xmm1 + LONG $0xc1670f66 // packuswb %xmm1, %xmm0 + QUAD $0xfffffe3005fc0f66 // paddb $-464(%rip), %xmm0 /* LCPI7_4(%rip) */ + WORD $0xc889 // movl %ecx, %eax + LONG $0x047f0ff3; BYTE $0x07 // movdqu %xmm0, (%rdi,%rax) + WORD $0xc983; BYTE $0x10 // orl $16, %ecx + WORD $0xc889 // movl %ecx, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + WORD $0x0000 // .p2align 4, 0x00 + +LCPI8_0: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI8_1: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI8_2: + QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' + + // .p2align 4, 0x90 +_quote: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x20ec8348 // subq $32, %rsp + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + WORD $0x8b4c; BYTE $0x11 // movq (%rcx), %r10 + LONG $0x01c0f641 // testb $1, %r8b + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0x380d8d48; WORD $0x00c7; BYTE $0x00 // leaq $51000(%rip), %rcx /* __SingleQuoteTab(%rip) */ + LONG $0x31258d4c; WORD $0x00d7; BYTE $0x00 // leaq $55089(%rip), %r12 /* __DoubleQuoteTab(%rip) */ + LONG $0xe1440f4c // cmoveq %rcx, %r12 + QUAD $0x00000000f50c8d48 // leaq (,%rsi,8), %rcx + WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 + LONG $0x03fc8d0f; WORD $0x0000 // jge LBB8_56, $1020(%rip) + WORD $0x894d; BYTE $0xfe // movq %r15, %r14 + WORD $0x8949; BYTE $0xf9 // movq %rdi, %r9 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x03dc840f; WORD $0x0000 // je LBB8_79, $988(%rip) + LONG $0xc85d894c // movq %r11, $-56(%rbp) + QUAD $0xffffff71056f0f66 // movdqa $-143(%rip), %xmm0 /* LCPI8_0(%rip) */ + QUAD $0xffffff790d6f0f66 // movdqa $-135(%rip), %xmm1 /* LCPI8_1(%rip) */ + QUAD $0xffffff81156f0f66 // movdqa $-127(%rip), %xmm2 /* LCPI8_2(%rip) */ + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + LONG $0xd07d894c // movq %r15, $-48(%rbp) + WORD $0x894d; BYTE $0xfe // movq %r15, %r14 + LONG $0xc065894c // movq %r12, $-64(%rbp) + +LBB8_3: + WORD $0x8949; BYTE $0xc9 // movq %rcx, %r9 + LONG $0x10f88348 // cmpq $16, %rax + WORD $0x9d0f; BYTE $0xc3 // setge %bl + WORD $0x894d; BYTE $0xd4 // movq %r10, %r12 + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + LONG $0x10fa8349 // cmpq $16, %r10 + LONG $0x007b8c0f; WORD $0x0000 // jl LBB8_10, $123(%rip) + LONG $0x10f88348 // cmpq $16, %rax + LONG $0x00718c0f; WORD $0x0000 // jl LBB8_10, $113(%rip) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx + + // .p2align 4, 0x90 +LBB8_6: + LONG $0x6f0f43f3; WORD $0x391c // movdqu (%r9,%r15), %xmm3 + LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 + LONG $0x7f0f43f3; WORD $0x3e1c // movdqu %xmm3, (%r14,%r15) + LONG $0xeb6f0f66 // movdqa %xmm3, %xmm5 + LONG $0xeada0f66 // pminub %xmm2, %xmm5 + LONG $0xeb740f66 // pcmpeqb %xmm3, %xmm5 + LONG $0xd8740f66 // pcmpeqb %xmm0, %xmm3 + LONG $0xe1740f66 // pcmpeqb %xmm1, %xmm4 + LONG $0xe3eb0f66 // por %xmm3, %xmm4 + LONG $0xeceb0f66 // por %xmm4, %xmm5 + LONG $0xcdd70f66 // pmovmskb %xmm5, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0132850f; WORD $0x0000 // jne LBB8_23, $306(%rip) + LONG $0xf05e8d4c // leaq $-16(%rsi), %r11 + LONG $0xf0628d4c // leaq $-16(%rdx), %r12 + LONG $0x10c78349 // addq $16, %r15 + LONG $0x20fe8348 // cmpq $32, %rsi + WORD $0x9d0f; BYTE $0xc3 // setge %bl + LONG $0x00108c0f; WORD $0x0000 // jl LBB8_9, $16(%rip) + WORD $0x894c; BYTE $0xde // movq %r11, %rsi + LONG $0x1ffa8348 // cmpq $31, %rdx + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xff9f8f0f; WORD $0xffff // jg LBB8_6, $-97(%rip) + +LBB8_9: + LONG $0x392c8d4f // leaq (%r9,%r15), %r13 + WORD $0x014d; BYTE $0xf7 // addq %r14, %r15 + +LBB8_10: + WORD $0xdb84 // testb %bl, %bl + LONG $0x006b840f; WORD $0x0000 // je LBB8_14, $107(%rip) + LONG $0x6f0f41f3; WORD $0x005d // movdqu (%r13), %xmm3 + LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 + LONG $0xeb6f0f66 // movdqa %xmm3, %xmm5 + LONG $0xeada0f66 // pminub %xmm2, %xmm5 + LONG $0xeb740f66 // pcmpeqb %xmm3, %xmm5 + LONG $0x7e0f4866; BYTE $0xd9 // movq %xmm3, %rcx + LONG $0xd8740f66 // pcmpeqb %xmm0, %xmm3 + LONG $0xe1740f66 // pcmpeqb %xmm1, %xmm4 + LONG $0xe3eb0f66 // por %xmm3, %xmm4 + LONG $0xeceb0f66 // por %xmm4, %xmm5 + LONG $0xd5d70f66 // pmovmskb %xmm5, %edx + LONG $0x0000ca81; WORD $0x0001 // orl $65536, %edx + LONG $0xdabc0f44 // bsfl %edx, %r11d + WORD $0x394d; BYTE $0xdc // cmpq %r11, %r12 + LONG $0x00c88d0f; WORD $0x0000 // jge LBB8_24, $200(%rip) + LONG $0x08fc8349 // cmpq $8, %r12 + LONG $0x00fd820f; WORD $0x0000 // jb LBB8_28, $253(%rip) + WORD $0x8949; BYTE $0x0f // movq %rcx, (%r15) + LONG $0x085d8d4d // leaq $8(%r13), %r11 + LONG $0x08c78349 // addq $8, %r15 + LONG $0x245c8d49; BYTE $0xf8 // leaq $-8(%r12), %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x00f38d0f; WORD $0x0000 // jge LBB8_29, $243(%rip) + LONG $0x000100e9; BYTE $0x00 // jmp LBB8_30, $256(%rip) + +LBB8_14: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x006e8e0f; WORD $0x0000 // jle LBB8_21, $110(%rip) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x00658e0f; WORD $0x0000 // jle LBB8_21, $101(%rip) + LONG $0xb84d894c // movq %r9, $-72(%rbp) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0xd231 // xorl %edx, %edx + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB8_17: + LONG $0x4cb60f43; WORD $0x000d // movzbl (%r13,%r9), %ecx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0x04e3c148 // shlq $4, %rbx + LONG $0x9c358d48; WORD $0x00c5; BYTE $0x00 // leaq $50588(%rip), %rsi /* __SingleQuoteTab(%rip) */ + LONG $0x333c8348; BYTE $0x00 // cmpq $0, (%rbx,%rsi) + LONG $0x008b850f; WORD $0x0000 // jne LBB8_27, $139(%rip) + LONG $0x13048d4d // leaq (%r11,%rdx), %r8 + LONG $0x0f0c8843 // movb %cl, (%r15,%r9) + LONG $0xff5a8d48 // leaq $-1(%rdx), %rbx + LONG $0x02f88349 // cmpq $2, %r8 + LONG $0x00138c0f; WORD $0x0000 // jl LBB8_20, $19(%rip) + WORD $0x014c; BYTE $0xe2 // addq %r12, %rdx + WORD $0xff49; BYTE $0xc1 // incq %r9 + LONG $0x01fa8348 // cmpq $1, %rdx + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx + LONG $0xffb88f0f; WORD $0xffff // jg LBB8_17, $-72(%rip) + +LBB8_20: + WORD $0x2949; BYTE $0xdd // subq %rbx, %r13 + WORD $0x0149; BYTE $0xdb // addq %rbx, %r11 + LONG $0xb84d8b4c // movq $-72(%rbp), %r9 + +LBB8_21: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0xc0658b4c // movq $-64(%rbp), %r12 + LONG $0x0043840f; WORD $0x0000 // je LBB8_26, $67(%rip) + WORD $0xf749; BYTE $0xd5 // notq %r13 + WORD $0x014d; BYTE $0xcd // addq %r9, %r13 + LONG $0x000129e9; BYTE $0x00 // jmp LBB8_41, $297(%rip) + +LBB8_23: + LONG $0xc9bc0f66 // bsfw %cx, %cx + LONG $0xe9b70f44 // movzwl %cx, %r13d + WORD $0x014d; BYTE $0xfd // addq %r15, %r13 + LONG $0x000115e9; BYTE $0x00 // jmp LBB8_40, $277(%rip) + +LBB8_24: + LONG $0x08fb8341 // cmpl $8, %r11d + LONG $0x00a4820f; WORD $0x0000 // jb LBB8_34, $164(%rip) + WORD $0x8949; BYTE $0x0f // movq %rcx, (%r15) + LONG $0x08658d4d // leaq $8(%r13), %r12 + LONG $0x08c78349 // addq $8, %r15 + LONG $0xf85b8d49 // leaq $-8(%r11), %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x009b830f; WORD $0x0000 // jae LBB8_35, $155(%rip) + LONG $0x0000a9e9; BYTE $0x00 // jmp LBB8_36, $169(%rip) + +LBB8_26: + WORD $0x294d; BYTE $0xcd // subq %r9, %r13 + LONG $0x0000e9e9; BYTE $0x00 // jmp LBB8_41, $233(%rip) + +LBB8_27: + LONG $0xb84d8b4c // movq $-72(%rbp), %r9 + WORD $0x294d; BYTE $0xcd // subq %r9, %r13 + WORD $0x2949; BYTE $0xd5 // subq %rdx, %r13 + LONG $0x0000d6e9; BYTE $0x00 // jmp LBB8_40, $214(%rip) + +LBB8_28: + WORD $0x894d; BYTE $0xeb // movq %r13, %r11 + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x00128c0f; WORD $0x0000 // jl LBB8_30, $18(%rip) + +LBB8_29: + WORD $0x8b41; BYTE $0x0b // movl (%r11), %ecx + WORD $0x8941; BYTE $0x0f // movl %ecx, (%r15) + LONG $0x04c38349 // addq $4, %r11 + LONG $0x04c78349 // addq $4, %r15 + LONG $0xfcc38348 // addq $-4, %rbx + +LBB8_30: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0022820f; WORD $0x0000 // jb LBB8_31, $34(%rip) + LONG $0x0bb70f41 // movzwl (%r11), %ecx + LONG $0x0f894166 // movw %cx, (%r15) + LONG $0x02c38349 // addq $2, %r11 + LONG $0x02c78349 // addq $2, %r15 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x000e850f; WORD $0x0000 // jne LBB8_32, $14(%rip) + LONG $0x000010e9; BYTE $0x00 // jmp LBB8_33, $16(%rip) + +LBB8_31: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0007840f; WORD $0x0000 // je LBB8_33, $7(%rip) + +LBB8_32: + LONG $0x0bb60f41 // movzbl (%r11), %ecx + WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) + +LBB8_33: + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0xf749; BYTE $0xd4 // notq %r12 + WORD $0x014d; BYTE $0xcc // addq %r9, %r12 + WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 + LONG $0x000067e9; BYTE $0x00 // jmp LBB8_40, $103(%rip) + +LBB8_34: + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + WORD $0x894c; BYTE $0xdb // movq %r11, %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x0013820f; WORD $0x0000 // jb LBB8_36, $19(%rip) + +LBB8_35: + LONG $0x240c8b41 // movl (%r12), %ecx + WORD $0x8941; BYTE $0x0f // movl %ecx, (%r15) + LONG $0x04c48349 // addq $4, %r12 + LONG $0x04c78349 // addq $4, %r15 + LONG $0xfcc38348 // addq $-4, %rbx + +LBB8_36: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0023820f; WORD $0x0000 // jb LBB8_37, $35(%rip) + LONG $0x0cb70f41; BYTE $0x24 // movzwl (%r12), %ecx + LONG $0x0f894166 // movw %cx, (%r15) + LONG $0x02c48349 // addq $2, %r12 + LONG $0x02c78349 // addq $2, %r15 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x000e850f; WORD $0x0000 // jne LBB8_38, $14(%rip) + LONG $0x000011e9; BYTE $0x00 // jmp LBB8_39, $17(%rip) + +LBB8_37: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0008840f; WORD $0x0000 // je LBB8_39, $8(%rip) + +LBB8_38: + LONG $0x0cb60f41; BYTE $0x24 // movzbl (%r12), %ecx + WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) + +LBB8_39: + WORD $0x294d; BYTE $0xcd // subq %r9, %r13 + WORD $0x014d; BYTE $0xdd // addq %r11, %r13 + +LBB8_40: + LONG $0xc0658b4c // movq $-64(%rbp), %r12 + +LBB8_41: + QUAD $0x000300000001bb49; WORD $0x0000 // movabsq $12884901889, %r11 + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x0323880f; WORD $0x0000 // js LBB8_82, $803(%rip) + WORD $0x014d; BYTE $0xee // addq %r13, %r14 + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00c2840f; WORD $0x0000 // je LBB8_78, $194(%rip) + WORD $0x294d; BYTE $0xea // subq %r13, %r10 + LONG $0x000015e9; BYTE $0x00 // jmp LBB8_45, $21(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB8_44: + WORD $0x0149; BYTE $0xf6 // addq %rsi, %r14 + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00a5840f; WORD $0x0000 // je LBB8_78, $165(%rip) + +LBB8_45: + LONG $0x0cb60f43; BYTE $0x29 // movzbl (%r9,%r13), %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x0c148b41 // movl (%r12,%rcx), %edx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0082840f; WORD $0x0000 // je LBB8_53, $130(%rip) + WORD $0x6348; BYTE $0xf2 // movslq %edx, %rsi + WORD $0x2949; BYTE $0xf2 // subq %rsi, %r10 + LONG $0x02b28c0f; WORD $0x0000 // jl LBB8_80, $690(%rip) + LONG $0x20e2c148 // shlq $32, %rdx + LONG $0x0c1c8d49 // leaq (%r12,%rcx), %rbx + LONG $0x08c38348 // addq $8, %rbx + WORD $0x394c; BYTE $0xda // cmpq %r11, %rdx + LONG $0x002a8c0f; WORD $0x0000 // jl LBB8_49, $42(%rip) + WORD $0x0b8b // movl (%rbx), %ecx + WORD $0x8941; BYTE $0x0e // movl %ecx, (%r14) + LONG $0x04c38348 // addq $4, %rbx + LONG $0x04468d4d // leaq $4(%r14), %r8 + LONG $0xfc4e8d48 // leaq $-4(%rsi), %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x001f830f; WORD $0x0000 // jae LBB8_50, $31(%rip) + LONG $0x00002de9; BYTE $0x00 // jmp LBB8_51, $45(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB8_49: + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x0013820f; WORD $0x0000 // jb LBB8_51, $19(%rip) + +LBB8_50: + WORD $0xb70f; BYTE $0x13 // movzwl (%rbx), %edx + LONG $0x10894166 // movw %dx, (%r8) + LONG $0x02c38348 // addq $2, %rbx + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec18348 // addq $-2, %rcx + +LBB8_51: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0xff64840f; WORD $0xffff // je LBB8_44, $-156(%rip) + WORD $0xb60f; BYTE $0x0b // movzbl (%rbx), %ecx + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + LONG $0xffff59e9; BYTE $0xff // jmp LBB8_44, $-167(%rip) + +LBB8_53: + LONG $0x290c8d4b // leaq (%r9,%r13), %rcx + WORD $0x294c; BYTE $0xe8 // subq %r13, %rax + LONG $0xfc59850f; WORD $0xffff // jne LBB8_3, $-935(%rip) + +LBB8_78: + WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 + LONG $0xc85d8b4c // movq $-56(%rbp), %r11 + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + +LBB8_79: + WORD $0x294d; BYTE $0xfe // subq %r15, %r14 + WORD $0x894d; BYTE $0x33 // movq %r14, (%r11) + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0x00022ae9; BYTE $0x00 // jmp LBB8_81, $554(%rip) + +LBB8_56: + QUAD $0xfffffb88056f0f66 // movdqa $-1144(%rip), %xmm0 /* LCPI8_0(%rip) */ + QUAD $0xfffffb900d6f0f66 // movdqa $-1136(%rip), %xmm1 /* LCPI8_1(%rip) */ + QUAD $0xfffffb98156f0f66 // movdqa $-1128(%rip), %xmm2 /* LCPI8_2(%rip) */ + LONG $0x010d8d4c; WORD $0x00e3; BYTE $0x00 // leaq $58113(%rip), %r9 /* __EscTab(%rip) */ + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + +LBB8_57: + LONG $0x10fb8348 // cmpq $16, %rbx + LONG $0x004b8c0f; WORD $0x0000 // jl LBB8_60, $75(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB8_58: + LONG $0x1f6f0ff3 // movdqu (%rdi), %xmm3 + LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 + LONG $0x1e7f0ff3 // movdqu %xmm3, (%rsi) + LONG $0xeb6f0f66 // movdqa %xmm3, %xmm5 + LONG $0xeada0f66 // pminub %xmm2, %xmm5 + LONG $0xeb740f66 // pcmpeqb %xmm3, %xmm5 + LONG $0xd8740f66 // pcmpeqb %xmm0, %xmm3 + LONG $0xe1740f66 // pcmpeqb %xmm1, %xmm4 + LONG $0xe3eb0f66 // por %xmm3, %xmm4 + LONG $0xeceb0f66 // por %xmm4, %xmm5 + LONG $0xcdd70f66 // pmovmskb %xmm5, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0128850f; WORD $0x0000 // jne LBB8_70, $296(%rip) + LONG $0x10c78348 // addq $16, %rdi + LONG $0x10c68348 // addq $16, %rsi + LONG $0xf0c38348 // addq $-16, %rbx + LONG $0x10fb8348 // cmpq $16, %rbx + LONG $0xffb6830f; WORD $0xffff // jae LBB8_58, $-74(%rip) + +LBB8_60: + LONG $0x08fb8348 // cmpq $8, %rbx + LONG $0x007b8c0f; WORD $0x0000 // jl LBB8_64, $123(%rip) + WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + LONG $0x0157b60f // movzbl $1(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xd200 // addb %dl, %dl + LONG $0x09140a42 // orb (%rcx,%r9), %dl + LONG $0x024fb60f // movzbl $2(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl + WORD $0xd108 // orb %dl, %cl + LONG $0x0357b60f // movzbl $3(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl + WORD $0xca08 // orb %cl, %dl + WORD $0x8b48; BYTE $0x0f // movq (%rdi), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x011f850f; WORD $0x0000 // jne LBB8_75, $287(%rip) + LONG $0x044fb60f // movzbl $4(%rdi), %ecx + LONG $0x0557b60f // movzbl $5(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xd200 // addb %dl, %dl + LONG $0x09140a42 // orb (%rcx,%r9), %dl + LONG $0x064fb60f // movzbl $6(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl + WORD $0xd108 // orb %dl, %cl + LONG $0x0757b60f // movzbl $7(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl + WORD $0xca08 // orb %cl, %dl + LONG $0x00f5850f; WORD $0x0000 // jne LBB8_76, $245(%rip) + LONG $0x08c68348 // addq $8, %rsi + LONG $0x08c78348 // addq $8, %rdi + LONG $0xf8c38348 // addq $-8, %rbx + +LBB8_64: + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x00448c0f; WORD $0x0000 // jl LBB8_67, $68(%rip) + WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + LONG $0x0157b60f // movzbl $1(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xd200 // addb %dl, %dl + LONG $0x09140a42 // orb (%rcx,%r9), %dl + LONG $0x024fb60f // movzbl $2(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx + WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl + WORD $0xd108 // orb %dl, %cl + LONG $0x0357b60f // movzbl $3(%rdi), %edx + LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx + WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl + WORD $0xca08 // orb %cl, %dl + WORD $0x0f8b // movl (%rdi), %ecx + WORD $0x0e89 // movl %ecx, (%rsi) + LONG $0x009c850f; WORD $0x0000 // jne LBB8_75, $156(%rip) + LONG $0x04c68348 // addq $4, %rsi + LONG $0x04c78348 // addq $4, %rdi + LONG $0xfcc38348 // addq $-4, %rbx + +LBB8_67: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00b28e0f; WORD $0x0000 // jle LBB8_77, $178(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB8_68: + WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + LONG $0x093c8042; BYTE $0x00 // cmpb $0, (%rcx,%r9) + LONG $0x002e850f; WORD $0x0000 // jne LBB8_72, $46(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0x0e88 // movb %cl, (%rsi) + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xff4b8d48 // leaq $-1(%rbx), %rcx + LONG $0x01fb8348 // cmpq $1, %rbx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0xffd98f0f; WORD $0xffff // jg LBB8_68, $-39(%rip) + LONG $0x00007ce9; BYTE $0x00 // jmp LBB8_77, $124(%rip) + +LBB8_70: + LONG $0xc9bc0f66 // bsfw %cx, %cx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + +LBB8_71: + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi + WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + +LBB8_72: + WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + BYTE $0x90 // .p2align 4, 0x90 + +LBB8_73: + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x0c346349 // movslq (%r12,%rcx), %rsi + LONG $0x0c4c8b49; BYTE $0x08 // movq $8(%r12,%rcx), %rcx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x00458c0f; WORD $0x0000 // jl LBB8_77, $69(%rip) + WORD $0xff48; BYTE $0xcb // decq %rbx + LONG $0x014fb60f // movzbl $1(%rdi), %ecx + WORD $0xff48; BYTE $0xc7 // incq %rdi + LONG $0x093c8042; BYTE $0x00 // cmpb $0, (%rcx,%r9) + LONG $0xffc8850f; WORD $0xffff // jne LBB8_73, $-56(%rip) + LONG $0xfffe48e9; BYTE $0xff // jmp LBB8_57, $-440(%rip) + +LBB8_75: + WORD $0xb60f; BYTE $0xca // movzbl %dl, %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + LONG $0xffffabe9; BYTE $0xff // jmp LBB8_71, $-85(%rip) + +LBB8_76: + WORD $0xb60f; BYTE $0xca // movzbl %dl, %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + LONG $0x04518d48 // leaq $4(%rcx), %rdx + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi + LONG $0x04c78348 // addq $4, %rdi + WORD $0x2948; BYTE $0xd3 // subq %rdx, %rbx + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + LONG $0x04c68348 // addq $4, %rsi + LONG $0xffff94e9; BYTE $0xff // jmp LBB8_72, $-108(%rip) + +LBB8_77: + WORD $0x294c; BYTE $0xfe // subq %r15, %rsi + WORD $0x8949; BYTE $0x33 // movq %rsi, (%r11) + LONG $0x000017e9; BYTE $0x00 // jmp LBB8_81, $23(%rip) + +LBB8_80: + LONG $0xd0752b4c // subq $-48(%rbp), %r14 + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x30 // movq %r14, (%rax) + WORD $0x294c; BYTE $0xcf // subq %r9, %rdi + WORD $0xf749; BYTE $0xd5 // notq %r13 + WORD $0x0149; BYTE $0xfd // addq %rdi, %r13 + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + +LBB8_81: + LONG $0x20c48348 // addq $32, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB8_82: + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + WORD $0x294c; BYTE $0xcf // subq %r9, %rdi + WORD $0x014c; BYTE $0xef // addq %r13, %rdi + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0xffffcfe9; BYTE $0xff // jmp LBB8_81, $-49(%rip) + LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI9_0: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + + // .p2align 4, 0x90 +_unquote: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x48ec8348 // subq $72, %rsp + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x062b840f; WORD $0x0000 // je LBB9_1, $1579(%rip) + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8945; BYTE $0xc2 // movl %r8d, %r10d + LONG $0x01e28341 // andl $1, %r10d + LONG $0x84258d4c; WORD $0x00e1; BYTE $0x00 // leaq $57732(%rip), %r12 /* __UnquoteTab(%rip) */ + QUAD $0xffffffbc0d6f0f66 // movdqa $-68(%rip), %xmm1 /* LCPI9_0(%rip) */ + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + LONG $0xb845894c // movq %r8, $-72(%rbp) + +LBB9_4: + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x0015850f; WORD $0x0000 // jne LBB9_6, $21(%rip) + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + LONG $0x0000cde9; BYTE $0x00 // jmp LBB9_18, $205(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_6: + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + WORD $0x894d; BYTE $0xfb // movq %r15, %r11 + LONG $0x10fd8349 // cmpq $16, %r13 + LONG $0x00458c0f; WORD $0x0000 // jl LBB9_12, $69(%rip) + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB9_8: + LONG $0x6f0f41f3; WORD $0x0f04 // movdqu (%r15,%rcx), %xmm0 + LONG $0x7f0f41f3; WORD $0x0e04 // movdqu %xmm0, (%r14,%rcx) + LONG $0xc1740f66 // pcmpeqb %xmm1, %xmm0 + LONG $0xd8d70f66 // pmovmskb %xmm0, %ebx + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x006b850f; WORD $0x0000 // jne LBB9_9, $107(%rip) + LONG $0xf0488d4c // leaq $-16(%rax), %r9 + LONG $0x10c18348 // addq $16, %rcx + LONG $0x1ff88348 // cmpq $31, %rax + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0xffcf870f; WORD $0xffff // ja LBB9_8, $-49(%rip) + LONG $0x0f1c8d4d // leaq (%r15,%rcx), %r11 + WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + +LBB9_12: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x058a840f; WORD $0x0000 // je LBB9_2, $1418(%rip) + WORD $0xc031 // xorl %eax, %eax + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_14: + LONG $0x1cb60f41; BYTE $0x03 // movzbl (%r11,%rax), %ebx + WORD $0xfb80; BYTE $0x5c // cmpb $92, %bl + LONG $0x0014840f; WORD $0x0000 // je LBB9_16, $20(%rip) + WORD $0x1c88; BYTE $0x01 // movb %bl, (%rcx,%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0xffe3850f; WORD $0xffff // jne LBB9_14, $-29(%rip) + LONG $0x000559e9; BYTE $0x00 // jmp LBB9_2, $1369(%rip) + +LBB9_16: + WORD $0x294d; BYTE $0xfb // subq %r15, %r11 + WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + LONG $0xfffb8349 // cmpq $-1, %r11 + LONG $0x001e850f; WORD $0x0000 // jne LBB9_18, $30(%rip) + LONG $0x000544e9; BYTE $0x00 // jmp LBB9_2, $1348(%rip) + +LBB9_9: + LONG $0xc3bc0f66 // bsfw %bx, %ax + LONG $0xd8b70f44 // movzwl %ax, %r11d + WORD $0x0149; BYTE $0xcb // addq %rcx, %r11 + LONG $0xfffb8349 // cmpq $-1, %r11 + LONG $0x052f840f; WORD $0x0000 // je LBB9_2, $1327(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB9_18: + LONG $0x024b8d49 // leaq $2(%r11), %rcx + WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 + LONG $0x05ea880f; WORD $0x0000 // js LBB9_19, $1514(%rip) + WORD $0x014d; BYTE $0xdf // addq %r11, %r15 + LONG $0x02c78349 // addq $2, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0251850f; WORD $0x0000 // jne LBB9_21, $593(%rip) + +LBB9_32: + WORD $0x014d; BYTE $0xde // addq %r11, %r14 + LONG $0x47b60f41; BYTE $0xff // movzbl $-1(%r15), %eax + LONG $0x04b60f42; BYTE $0x20 // movzbl (%rax,%r12), %eax + LONG $0x0000ff3d; BYTE $0x00 // cmpl $255, %eax + LONG $0x002b840f; WORD $0x0000 // je LBB9_38, $43(%rip) + WORD $0xc085 // testl %eax, %eax + LONG $0x05d5840f; WORD $0x0000 // je LBB9_34, $1493(%rip) + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfed5850f; WORD $0xffff // jne LBB9_4, $-299(%rip) + LONG $0x0005b9e9; BYTE $0x00 // jmp LBB9_37, $1465(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_38: + LONG $0x03fd8349 // cmpq $3, %r13 + LONG $0x058d860f; WORD $0x0000 // jbe LBB9_19, $1421(%rip) + WORD $0x8b41; BYTE $0x1f // movl (%r15), %ebx + WORD $0xd989 // movl %ebx, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0xcfd0838d; WORD $0xcfcf // leal $-808464432(%rbx), %eax + LONG $0x8080e181; WORD $0x8080 // andl $-2139062144, %ecx + WORD $0xc185 // testl %eax, %ecx + LONG $0x04be850f; WORD $0x0000 // jne LBB9_43, $1214(%rip) + LONG $0x1919838d; WORD $0x1919 // leal $421075225(%rbx), %eax + WORD $0xd809 // orl %ebx, %eax + LONG $0x808080a9; BYTE $0x80 // testl $-2139062144, %eax + LONG $0x04ab850f; WORD $0x0000 // jne LBB9_43, $1195(%rip) + WORD $0xd889 // movl %ebx, %eax + LONG $0x7f7f7f25; BYTE $0x7f // andl $2139062143, %eax + LONG $0xc0c0bb41; WORD $0xc0c0 // movl $-1061109568, %r11d + WORD $0x2941; BYTE $0xc3 // subl %eax, %r11d + LONG $0x46888d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rax), %r9d + WORD $0x2141; BYTE $0xcb // andl %ecx, %r11d + WORD $0x8545; BYTE $0xcb // testl %r9d, %r11d + LONG $0x0488850f; WORD $0x0000 // jne LBB9_43, $1160(%rip) + LONG $0xe0e0b941; WORD $0xe0e0 // movl $-522133280, %r9d + WORD $0x2941; BYTE $0xc1 // subl %eax, %r9d + LONG $0x39393905; BYTE $0x39 // addl $960051513, %eax + WORD $0x2144; BYTE $0xc9 // andl %r9d, %ecx + WORD $0xc185 // testl %eax, %ecx + LONG $0x046f850f; WORD $0x0000 // jne LBB9_43, $1135(%rip) + WORD $0xcb0f // bswapl %ebx + WORD $0xd989 // movl %ebx, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + LONG $0x0101e181; WORD $0x0101 // andl $16843009, %ecx + WORD $0x0c8d; BYTE $0xc9 // leal (%rcx,%rcx,8), %ecx + LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx + WORD $0xcb01 // addl %ecx, %ebx + WORD $0xd989 // movl %ebx, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xd909 // orl %ebx, %ecx + WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx + LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx + WORD $0xcb09 // orl %ecx, %ebx + LONG $0x044f8d4d // leaq $4(%r15), %r9 + LONG $0xfc4d8d49 // leaq $-4(%r13), %rcx + LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx + LONG $0x01a7820f; WORD $0x0000 // jb LBB9_54, $423(%rip) + LONG $0x02c0f641 // testb $2, %r8b + LONG $0x01ae840f; WORD $0x0000 // je LBB9_65, $430(%rip) + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + +LBB9_59: + LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d + LONG $0x028b860f; WORD $0x0000 // jbe LBB9_67, $651(%rip) + QUAD $0xffff200024848d41 // leal $-57344(%r12), %eax + LONG $0xfff7ff3d; BYTE $0xff // cmpl $-2049, %eax + LONG $0x01b6860f; WORD $0x0000 // jbe LBB9_70, $438(%rip) + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xc07d8948 // movq %rdi, $-64(%rbp) + LONG $0xb0758948 // movq %rsi, $-80(%rbp) + LONG $0x00ca850f; WORD $0x0000 // jne LBB9_62, $202(%rip) + LONG $0xa855894c // movq %r10, $-88(%rbp) + LONG $0xa0558948 // movq %rdx, $-96(%rbp) + LONG $0x06fd8349 // cmpq $6, %r13 + LONG $0x00e38c0f; WORD $0x0000 // jl LBB9_94, $227(%rip) + +LBB9_91: + LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d + LONG $0x00d6870f; WORD $0x0000 // ja LBB9_94, $214(%rip) + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x00cc850f; WORD $0x0000 // jne LBB9_94, $204(%rip) + LONG $0x017f8041; BYTE $0x75 // cmpb $117, $1(%r15) + LONG $0x00c1850f; WORD $0x0000 // jne LBB9_94, $193(%rip) + LONG $0x025f8b41 // movl $2(%r15), %ebx + WORD $0xdf89 // movl %ebx, %edi + LONG $0x0005e6e8; BYTE $0x00 // callq _unhex16_is, $1510(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x04d2840f; WORD $0x0000 // je LBB9_100, $1234(%rip) + WORD $0xcb0f // bswapl %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx + WORD $0xc301 // addl %eax, %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xd809 // orl %ebx, %eax + WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx + WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax + LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax + WORD $0x1c8d; BYTE $0x08 // leal (%rax,%rcx), %ebx + LONG $0x06c78349 // addq $6, %r15 + LONG $0xfac58349 // addq $-6, %r13 + WORD $0xc801 // addl %ecx, %eax + LONG $0xff200005; BYTE $0xff // addl $-57344, %eax + LONG $0xfffbff3d; BYTE $0xff // cmpl $-1025, %eax + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + LONG $0xa0558b48 // movq $-96(%rbp), %rdx + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + QUAD $0xfffffcd80d6f0f66 // movdqa $-808(%rip), %xmm1 /* LCPI9_0(%rip) */ + LONG $0x0144870f; WORD $0x0000 // ja LBB9_110, $324(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx + LONG $0xa8558b4c // movq $-88(%rbp), %r10 + LONG $0xff0a830f; WORD $0xffff // jae LBB9_59, $-246(%rip) + LONG $0x00009fe9; BYTE $0x00 // jmp LBB9_55, $159(%rip) + +LBB9_62: + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x04218e0f; WORD $0x0000 // jle LBB9_63, $1057(%rip) + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x026f850f; WORD $0x0000 // jne LBB9_96, $623(%rip) + WORD $0xff49; BYTE $0xcd // decq %r13 + WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0xa855894c // movq %r10, $-88(%rbp) + LONG $0xa0558948 // movq %rdx, $-96(%rbp) + LONG $0x06fd8349 // cmpq $6, %r13 + LONG $0xff1d8d0f; WORD $0xffff // jge LBB9_91, $-227(%rip) + +LBB9_94: + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x02a9840f; WORD $0x0000 // je LBB9_77, $681(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + LONG $0x00011ae9; BYTE $0x00 // jmp LBB9_86, $282(%rip) + +LBB9_21: + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x0380840f; WORD $0x0000 // je LBB9_19, $896(%rip) + LONG $0xff7f8041; BYTE $0x5c // cmpb $92, $-1(%r15) + LONG $0x03a9850f; WORD $0x0000 // jne LBB9_23, $937(%rip) + LONG $0x5c3f8041 // cmpb $92, (%r15) + LONG $0x0027850f; WORD $0x0000 // jne LBB9_31, $39(%rip) + LONG $0x01fd8341 // cmpl $1, %r13d + LONG $0x03618e0f; WORD $0x0000 // jle LBB9_19, $865(%rip) + LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx + WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx + LONG $0x0009840f; WORD $0x0000 // je LBB9_30, $9(%rip) + WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx + LONG $0x0397850f; WORD $0x0000 // jne LBB9_29, $919(%rip) + +LBB9_30: + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xff49; BYTE $0xcd // decq %r13 + +LBB9_31: + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xff49; BYTE $0xcd // decq %r13 + LONG $0xfffd5fe9; BYTE $0xff // jmp LBB9_32, $-673(%rip) + +LBB9_54: + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + +LBB9_55: + WORD $0x8841; BYTE $0x1e // movb %bl, (%r14) + WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0x00005ae9; BYTE $0x00 // jmp LBB9_56, $90(%rip) + +LBB9_65: + LONG $0x0800fb81; WORD $0x0000 // cmpl $2048, %ebx + LONG $0x00de820f; WORD $0x0000 // jb LBB9_66, $222(%rip) + LONG $0x2000838d; WORD $0xffff // leal $-57344(%rbx), %eax + LONG $0xfff8003d; BYTE $0xff // cmpl $-2048, %eax + LONG $0x00f6830f; WORD $0x0000 // jae LBB9_71, $246(%rip) + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB9_70: + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + WORD $0xe8c1; BYTE $0x0c // shrl $12, %eax + WORD $0xe00c // orb $-32, %al + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x01468841 // movb %al, $1(%r14) + LONG $0x3fe48041 // andb $63, %r12b + LONG $0x80cc8041 // orb $-128, %r12b + LONG $0x02668845 // movb %r12b, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + +LBB9_56: + LONG $0xb8458b4c // movq $-72(%rbp), %r8 + LONG $0x5c258d4c; WORD $0x00dd; BYTE $0x00 // leaq $56668(%rip), %r12 /* __UnquoteTab(%rip) */ + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfbe4850f; WORD $0xffff // jne LBB9_4, $-1052(%rip) + LONG $0x0002c8e9; BYTE $0x00 // jmp LBB9_37, $712(%rip) + +LBB9_110: + WORD $0xd889 // movl %ebx, %eax + +LBB9_85: + LONG $0x0ae4c141 // shll $10, %r12d + WORD $0xc189 // movl %eax, %ecx + WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx + WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax + LONG $0xa0240005; BYTE $0xfc // addl $-56613888, %eax + WORD $0xc289 // movl %eax, %edx + WORD $0xeac1; BYTE $0x12 // shrl $18, %edx + WORD $0xca80; BYTE $0xf0 // orb $-16, %dl + WORD $0x8841; BYTE $0x16 // movb %dl, (%r14) + WORD $0xc289 // movl %eax, %edx + WORD $0xeac1; BYTE $0x0c // shrl $12, %edx + WORD $0xe280; BYTE $0x3f // andb $63, %dl + WORD $0xca80; BYTE $0x80 // orb $-128, %dl + LONG $0x01568841 // movb %dl, $1(%r14) + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x02468841 // movb %al, $2(%r14) + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + LONG $0x034e8841 // movb %cl, $3(%r14) + LONG $0x04c68349 // addq $4, %r14 + +LBB9_86: + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + LONG $0xa0558b48 // movq $-96(%rbp), %rdx + LONG $0xa8558b4c // movq $-88(%rbp), %r10 + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + LONG $0xb8458b4c // movq $-72(%rbp), %r8 + LONG $0xed258d4c; WORD $0x00dc; BYTE $0x00 // leaq $56557(%rip), %r12 /* __UnquoteTab(%rip) */ + QUAD $0xfffffb250d6f0f66 // movdqa $-1243(%rip), %xmm1 /* LCPI9_0(%rip) */ + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfb6d850f; WORD $0xffff // jne LBB9_4, $-1171(%rip) + LONG $0x000251e9; BYTE $0x00 // jmp LBB9_37, $593(%rip) + +LBB9_66: + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 + WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + +LBB9_67: + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0xc00c // orb $-64, %al + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + LONG $0x3fe48041 // andb $63, %r12b + LONG $0x80cc8041 // orb $-128, %r12b + LONG $0x01668845 // movb %r12b, $1(%r14) + LONG $0x02c68349 // addq $2, %r14 + LONG $0xffff47e9; BYTE $0xff // jmp LBB9_56, $-185(%rip) + +LBB9_71: + WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 + LONG $0x984d8948 // movq %rcx, $-104(%rbp) + LONG $0xc84d894c // movq %r9, $-56(%rbp) + LONG $0xb0758948 // movq %rsi, $-80(%rbp) + LONG $0xa0558948 // movq %rdx, $-96(%rbp) + LONG $0xc07d8948 // movq %rdi, $-64(%rbp) + LONG $0xa855894c // movq %r10, $-88(%rbp) + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x00c7850f; WORD $0x0000 // jne LBB9_72, $199(%rip) + LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) + LONG $0x00ee820f; WORD $0x0000 // jb LBB9_76, $238(%rip) + +LBB9_78: + LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d + LONG $0x00e1870f; WORD $0x0000 // ja LBB9_76, $225(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) + LONG $0x00d4850f; WORD $0x0000 // jne LBB9_76, $212(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + LONG $0x75017880 // cmpb $117, $1(%rax) + LONG $0x00c6850f; WORD $0x0000 // jne LBB9_76, $198(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x588b; BYTE $0x02 // movl $2(%rax), %ebx + WORD $0xdf89 // movl %ebx, %edi + LONG $0x000339e8; BYTE $0x00 // callq _unhex16_is, $825(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x0221840f; WORD $0x0000 // je LBB9_82, $545(%rip) + WORD $0xcb0f // bswapl %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx + WORD $0xc301 // addl %eax, %ebx + WORD $0xd889 // movl %ebx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xd809 // orl %ebx, %eax + WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx + WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax + LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax + LONG $0xc8458348; BYTE $0x06 // addq $6, $-56(%rbp) + WORD $0x148d; BYTE $0x08 // leal (%rax,%rcx), %edx + LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx + LONG $0xfc00fa81; WORD $0xffff // cmpl $-1024, %edx + LONG $0x02ae820f; WORD $0x0000 // jb LBB9_98, $686(%rip) + WORD $0xc809 // orl %ecx, %eax + LONG $0x986d8b4c // movq $-104(%rbp), %r13 + LONG $0xfac58349 // addq $-6, %r13 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + LONG $0xfffe9de9; BYTE $0xff // jmp LBB9_85, $-355(%rip) + +LBB9_96: + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x028d840f; WORD $0x0000 // je LBB9_97, $653(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + LONG $0xc07d8b48 // movq $-64(%rbp), %rdi + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + LONG $0xfffe5ce9; BYTE $0xff // jmp LBB9_56, $-420(%rip) + +LBB9_72: + LONG $0x05fd8349 // cmpq $5, %r13 + LONG $0x028a820f; WORD $0x0000 // jb LBB9_87, $650(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) + LONG $0x025e850f; WORD $0x0000 // jne LBB9_98, $606(%rip) + LONG $0xfbc58349 // addq $-5, %r13 + LONG $0x05c78349 // addq $5, %r15 + LONG $0x986d894c // movq %r13, $-104(%rbp) + LONG $0xc87d894c // movq %r15, $-56(%rbp) + LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) + LONG $0xff12830f; WORD $0xffff // jae LBB9_78, $-238(%rip) + +LBB9_76: + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + +LBB9_77: + LONG $0xa8458b48 // movq $-88(%rbp), %rax + LONG $0xc0450348 // addq $-64(%rbp), %rax + WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 + LONG $0xfcc78349 // addq $-4, %r15 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 + LONG $0x00000ce9; BYTE $0x00 // jmp LBB9_52, $12(%rip) + +LBB9_1: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + +LBB9_2: + WORD $0x014d; BYTE $0xee // addq %r13, %r14 + WORD $0x2949; BYTE $0xd6 // subq %rdx, %r14 + +LBB9_52: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + LONG $0x48c48348 // addq $72, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB9_43: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + LONG $0xd0758b48 // movq $-48(%rbp), %rsi + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0x0fb60f41 // movzbl (%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_45, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xffbb820f; WORD $0xffff // jb LBB9_52, $-69(%rip) + +LBB9_45: + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_47, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xff94820f; WORD $0xffff // jb LBB9_52, $-108(%rip) + +LBB9_47: + LONG $0x02488d48 // leaq $2(%rax), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_49, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xff6d820f; WORD $0xffff // jb LBB9_52, $-147(%rip) + +LBB9_49: + LONG $0x03488d48 // leaq $3(%rax), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_51, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xff46820f; WORD $0xffff // jb LBB9_52, $-186(%rip) + +LBB9_51: + LONG $0x04c08348 // addq $4, %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xffff3ae9; BYTE $0xff // jmp LBB9_52, $-198(%rip) + +LBB9_19: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + LONG $0xffff27e9; BYTE $0xff // jmp LBB9_52, $-217(%rip) + +LBB9_37: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + LONG $0xffff19e9; BYTE $0xff // jmp LBB9_2, $-231(%rip) + +LBB9_34: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0149; BYTE $0xff // addq %rdi, %r15 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + LONG $0xfdc6c749; WORD $0xffff; BYTE $0xff // movq $-3, %r14 + LONG $0xffff06e9; BYTE $0xff // jmp LBB9_52, $-250(%rip) + +LBB9_23: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0149; BYTE $0xff // addq %rdi, %r15 + +LBB9_24: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + LONG $0xfffeede9; BYTE $0xff // jmp LBB9_52, $-275(%rip) + +LBB9_29: + WORD $0x2949; BYTE $0xff // subq %rdi, %r15 + WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB9_24, $-30(%rip) + +LBB9_63: + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x0108840f; WORD $0x0000 // je LBB9_87, $264(%rip) + LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) + LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + LONG $0xfffebbe9; BYTE $0xff // jmp LBB9_2, $-325(%rip) + +LBB9_82: + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + +LBB9_100: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0xc0452b48 // subq $-64(%rbp), %rax + LONG $0x02c08348 // addq $2, %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_102, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe84820f; WORD $0xffff // jb LBB9_52, $-380(%rip) + +LBB9_102: + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_104, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe59820f; WORD $0xffff // jb LBB9_52, $-423(%rip) + +LBB9_104: + LONG $0x02488d48 // leaq $2(%rax), %rcx + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x4fb60f41; BYTE $0x04 // movzbl $4(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_106, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe2e820f; WORD $0xffff // jb LBB9_52, $-466(%rip) + +LBB9_106: + LONG $0x03488d48 // leaq $3(%rax), %rcx + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x4fb60f41; BYTE $0x05 // movzbl $5(%r15), %ecx + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB9_108, $15(%rip) + WORD $0xe180; BYTE $0xdf // andb $-33, %cl + WORD $0xc180; BYTE $0xb9 // addb $-71, %cl + WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl + LONG $0xfe03820f; WORD $0xffff // jb LBB9_52, $-509(%rip) + +LBB9_108: + LONG $0x04c08348 // addq $4, %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xfffdf3e9; BYTE $0xff // jmp LBB9_52, $-525(%rip) + +LBB9_97: + LONG $0xc87d894c // movq %r15, $-56(%rbp) + +LBB9_98: + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0xc0652b4c // subq $-64(%rbp), %r12 + LONG $0xfcc48349 // addq $-4, %r12 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x20 // movq %r12, (%rax) + LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 + LONG $0xfffdd0e9; BYTE $0xff // jmp LBB9_52, $-560(%rip) + +LBB9_87: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + LONG $0xb04d8b48 // movq $-80(%rbp), %rcx + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + LONG $0xfffdb9e9; BYTE $0xff // jmp LBB9_52, $-583(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +_unhex16_is: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0xf889 // movl %edi, %eax + WORD $0xd0f7 // notl %eax + LONG $0xcfd08f8d; WORD $0xcfcf // leal $-808464432(%rdi), %ecx + LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax + WORD $0xc885 // testl %ecx, %eax + LONG $0x0007840f; WORD $0x0000 // je LBB10_2, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB10_2: + LONG $0x19198f8d; WORD $0x1919 // leal $421075225(%rdi), %ecx + WORD $0xf909 // orl %edi, %ecx + LONG $0x8080c1f7; WORD $0x8080 // testl $-2139062144, %ecx + LONG $0x0007840f; WORD $0x0000 // je LBB10_4, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB10_4: + LONG $0x7f7fe781; WORD $0x7f7f // andl $2139062143, %edi + LONG $0xc0c0c0b9; BYTE $0xc0 // movl $-1061109568, %ecx + WORD $0xf929 // subl %edi, %ecx + LONG $0x4646978d; WORD $0x4646 // leal $1179010630(%rdi), %edx + WORD $0xc121 // andl %eax, %ecx + WORD $0xd185 // testl %edx, %ecx + LONG $0x0007840f; WORD $0x0000 // je LBB10_6, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB10_6: + LONG $0xe0e0e0b9; BYTE $0xe0 // movl $-522133280, %ecx + WORD $0xf929 // subl %edi, %ecx + LONG $0x3939c781; WORD $0x3939 // addl $960051513, %edi + WORD $0xc821 // andl %ecx, %eax + WORD $0xf885 // testl %edi, %eax + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI11_0: + QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&' + +LCPI11_1: + QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2' + +LCPI11_2: + QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd' + +LCPI11_3: + QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<' + + // .p2align 4, 0x90 +_html_escape: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x10ec8348 // subq $16, %rsp + LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + LONG $0xd0558948 // movq %rdx, $-48(%rbp) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x04b18e0f; WORD $0x0000 // jle LBB11_70, $1201(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8b4c; BYTE $0x08 // movq (%rax), %r9 + QUAD $0xffffff89056f0f66 // movdqa $-119(%rip), %xmm0 /* LCPI11_0(%rip) */ + QUAD $0xffffff910d6f0f66 // movdqa $-111(%rip), %xmm1 /* LCPI11_1(%rip) */ + QUAD $0xffffff99156f0f66 // movdqa $-103(%rip), %xmm2 /* LCPI11_2(%rip) */ + QUAD $0xffffffa11d6f0f66 // movdqa $-95(%rip), %xmm3 /* LCPI11_3(%rip) */ + LONG $0xfa1d8d4c; WORD $0x00d8; BYTE $0x00 // leaq $55546(%rip), %r11 /* __HtmlQuoteTab(%rip) */ + WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 + LONG $0xd0758b4c // movq $-48(%rbp), %r14 + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_2: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x048e8e0f; WORD $0x0000 // jle LBB11_3, $1166(%rip) + LONG $0x10fe8348 // cmpq $16, %rsi + WORD $0x930f; BYTE $0xc0 // setae %al + WORD $0x894d; BYTE $0xcd // movq %r9, %r13 + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + WORD $0x894d; BYTE $0xe7 // movq %r12, %r15 + LONG $0x10f98349 // cmpq $16, %r9 + LONG $0x0082820f; WORD $0x0000 // jb LBB11_12, $130(%rip) + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0x0078820f; WORD $0x0000 // jb LBB11_12, $120(%rip) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_7: + LONG $0x6f0f43f3; WORD $0x0424 // movdqu (%r12,%r8), %xmm4 + LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 + LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 + LONG $0x7f0f43f3; WORD $0x0624 // movdqu %xmm4, (%r14,%r8) + LONG $0xe0740f66 // pcmpeqb %xmm0, %xmm4 + LONG $0xe9740f66 // pcmpeqb %xmm1, %xmm5 + LONG $0xeceb0f66 // por %xmm4, %xmm5 + LONG $0xf2db0f66 // pand %xmm2, %xmm6 + LONG $0xf3740f66 // pcmpeqb %xmm3, %xmm6 + LONG $0xf5eb0f66 // por %xmm5, %xmm6 + LONG $0xc6d70f66 // pmovmskb %xmm6, %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x0158850f; WORD $0x0000 // jne LBB11_8, $344(%rip) + LONG $0xf04b8d48 // leaq $-16(%rbx), %rcx + LONG $0xf06a8d4c // leaq $-16(%rdx), %r13 + LONG $0x10c08349 // addq $16, %r8 + LONG $0x20fb8348 // cmpq $32, %rbx + WORD $0x9d0f; BYTE $0xc0 // setge %al + LONG $0x00108c0f; WORD $0x0000 // jl LBB11_11, $16(%rip) + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0x1ffa8348 // cmpq $31, %rdx + WORD $0x894c; BYTE $0xea // movq %r13, %rdx + LONG $0xff9f8f0f; WORD $0xffff // jg LBB11_7, $-97(%rip) + +LBB11_11: + LONG $0x043c8d4f // leaq (%r12,%r8), %r15 + WORD $0x014d; BYTE $0xf0 // addq %r14, %r8 + +LBB11_12: + WORD $0xc084 // testb %al, %al + LONG $0x0070840f; WORD $0x0000 // je LBB11_13, $112(%rip) + LONG $0x6f0f41f3; BYTE $0x27 // movdqu (%r15), %xmm4 + LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 + LONG $0xe8740f66 // pcmpeqb %xmm0, %xmm5 + LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 + LONG $0xf1740f66 // pcmpeqb %xmm1, %xmm6 + LONG $0xf5eb0f66 // por %xmm5, %xmm6 + LONG $0x7e0f4866; BYTE $0xe0 // movq %xmm4, %rax + LONG $0xe2db0f66 // pand %xmm2, %xmm4 + LONG $0xe3740f66 // pcmpeqb %xmm3, %xmm4 + LONG $0xe6eb0f66 // por %xmm6, %xmm4 + LONG $0xccd70f66 // pmovmskb %xmm4, %ecx + LONG $0x0000c981; WORD $0x0001 // orl $65536, %ecx + LONG $0xd1bc0f44 // bsfl %ecx, %r10d + WORD $0x394d; BYTE $0xd5 // cmpq %r10, %r13 + LONG $0x00f88d0f; WORD $0x0000 // jge LBB11_24, $248(%rip) + LONG $0x08fd8349 // cmpq $8, %r13 + LONG $0x0131820f; WORD $0x0000 // jb LBB11_35, $305(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0x08578d4d // leaq $8(%r15), %r10 + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf85d8d49 // leaq $-8(%r13), %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x01288d0f; WORD $0x0000 // jge LBB11_38, $296(%rip) + LONG $0x000135e9; BYTE $0x00 // jmp LBB11_39, $309(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_13: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x00878e0f; WORD $0x0000 // jle LBB11_21, $135(%rip) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x007e8e0f; WORD $0x0000 // jle LBB11_21, $126(%rip) + WORD $0xd231 // xorl %edx, %edx + WORD $0xc031 // xorl %eax, %eax + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB11_16: + LONG $0x1cb60f45; BYTE $0x17 // movzbl (%r15,%rdx), %r11d + LONG $0x3efb8349 // cmpq $62, %r11 + LONG $0x0014870f; WORD $0x0000 // ja LBB11_17, $20(%rip) + QUAD $0x004000000000bb48; WORD $0x5000 // movabsq $5764607797912141824, %rbx + LONG $0xdba30f4c // btq %r11, %rbx + LONG $0x00ae820f; WORD $0x0000 // jb LBB11_45, $174(%rip) + +LBB11_17: + LONG $0xe2fb8141; WORD $0x0000; BYTE $0x00 // cmpl $226, %r11d + LONG $0x00a1840f; WORD $0x0000 // je LBB11_45, $161(%rip) + LONG $0x01148d4c // leaq (%rcx,%rax), %r10 + LONG $0x101c8845 // movb %r11b, (%r8,%rdx) + LONG $0xff588d48 // leaq $-1(%rax), %rbx + LONG $0x02fa8349 // cmpq $2, %r10 + LONG $0x00138c0f; WORD $0x0000 // jl LBB11_20, $19(%rip) + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0x01f88348 // cmpq $1, %rax + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0xffa78f0f; WORD $0xffff // jg LBB11_16, $-89(%rip) + +LBB11_20: + WORD $0x2949; BYTE $0xdf // subq %rbx, %r15 + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + LONG $0x4a1d8d4c; WORD $0x00d7; BYTE $0x00 // leaq $55114(%rip), %r11 /* __HtmlQuoteTab(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB11_21: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0160840f; WORD $0x0000 // je LBB11_22, $352(%rip) + WORD $0xf749; BYTE $0xd7 // notq %r15 + WORD $0x014d; BYTE $0xe7 // addq %r12, %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0168890f; WORD $0x0000 // jns LBB11_49, $360(%rip) + LONG $0x000287e9; BYTE $0x00 // jmp LBB11_48, $647(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_8: + LONG $0xc0bc0f66 // bsfw %ax, %ax + LONG $0xf8b70f44 // movzwl %ax, %r15d + WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x014c890f; WORD $0x0000 // jns LBB11_49, $332(%rip) + LONG $0x00026be9; BYTE $0x00 // jmp LBB11_48, $619(%rip) + +LBB11_24: + LONG $0x08fa8341 // cmpl $8, %r10d + LONG $0x008f820f; WORD $0x0000 // jb LBB11_25, $143(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0x086f8d4d // leaq $8(%r15), %r13 + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf85a8d49 // leaq $-8(%r10), %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x0086830f; WORD $0x0000 // jae LBB11_28, $134(%rip) + LONG $0x000094e9; BYTE $0x00 // jmp LBB11_29, $148(%rip) + +LBB11_45: + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 + LONG $0xd21d8d4c; WORD $0x00d6; BYTE $0x00 // leaq $54994(%rip), %r11 /* __HtmlQuoteTab(%rip) */ + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0109890f; WORD $0x0000 // jns LBB11_49, $265(%rip) + LONG $0x000228e9; BYTE $0x00 // jmp LBB11_48, $552(%rip) + +LBB11_35: + WORD $0x894d; BYTE $0xfa // movq %r15, %r10 + WORD $0x894c; BYTE $0xeb // movq %r13, %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x00128c0f; WORD $0x0000 // jl LBB11_39, $18(%rip) + +LBB11_38: + WORD $0x8b41; BYTE $0x02 // movl (%r10), %eax + WORD $0x8941; BYTE $0x00 // movl %eax, (%r8) + LONG $0x04c28349 // addq $4, %r10 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc38348 // addq $-4, %rbx + +LBB11_39: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x007c830f; WORD $0x0000 // jae LBB11_40, $124(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0007840f; WORD $0x0000 // je LBB11_43, $7(%rip) + +LBB11_42: + LONG $0x02b60f41 // movzbl (%r10), %eax + WORD $0x8841; BYTE $0x00 // movb %al, (%r8) + +LBB11_43: + WORD $0x014d; BYTE $0xfd // addq %r15, %r13 + WORD $0xf749; BYTE $0xd5 // notq %r13 + WORD $0x014d; BYTE $0xe5 // addq %r12, %r13 + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x00b3890f; WORD $0x0000 // jns LBB11_49, $179(%rip) + LONG $0x0001d2e9; BYTE $0x00 // jmp LBB11_48, $466(%rip) + +LBB11_25: + WORD $0x894d; BYTE $0xfd // movq %r15, %r13 + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x0013820f; WORD $0x0000 // jb LBB11_29, $19(%rip) + +LBB11_28: + LONG $0x00458b41 // movl (%r13), %eax + WORD $0x8941; BYTE $0x00 // movl %eax, (%r8) + LONG $0x04c58349 // addq $4, %r13 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc38348 // addq $-4, %rbx + +LBB11_29: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0047830f; WORD $0x0000 // jae LBB11_30, $71(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0008840f; WORD $0x0000 // je LBB11_33, $8(%rip) + +LBB11_32: + LONG $0x45b60f41; BYTE $0x00 // movzbl (%r13), %eax + WORD $0x8841; BYTE $0x00 // movb %al, (%r8) + +LBB11_33: + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + WORD $0x014d; BYTE $0xd7 // addq %r10, %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0061890f; WORD $0x0000 // jns LBB11_49, $97(%rip) + LONG $0x000180e9; BYTE $0x00 // jmp LBB11_48, $384(%rip) + +LBB11_40: + LONG $0x02b70f41 // movzwl (%r10), %eax + LONG $0x00894166 // movw %ax, (%r8) + LONG $0x02c28349 // addq $2, %r10 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xff70850f; WORD $0xffff // jne LBB11_42, $-144(%rip) + LONG $0xffff72e9; BYTE $0xff // jmp LBB11_43, $-142(%rip) + +LBB11_30: + LONG $0x45b70f41; BYTE $0x00 // movzwl (%r13), %eax + LONG $0x00894166 // movw %ax, (%r8) + LONG $0x02c58349 // addq $2, %r13 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xffa4850f; WORD $0xffff // jne LBB11_32, $-92(%rip) + LONG $0xffffa7e9; BYTE $0xff // jmp LBB11_33, $-89(%rip) + +LBB11_22: + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x012f880f; WORD $0x0000 // js LBB11_48, $303(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB11_49: + WORD $0x014d; BYTE $0xfc // addq %r15, %r12 + WORD $0x014d; BYTE $0xfe // addq %r15, %r14 + WORD $0x294c; BYTE $0xfe // subq %r15, %rsi + LONG $0x01378e0f; WORD $0x0000 // jle LBB11_50, $311(%rip) + WORD $0x294d; BYTE $0xf9 // subq %r15, %r9 + LONG $0x0cb60f41; BYTE $0x24 // movzbl (%r12), %ecx + WORD $0xf980; BYTE $0xe2 // cmpb $-30, %cl + LONG $0x00b3840f; WORD $0x0000 // je LBB11_53, $179(%rip) + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + +LBB11_57: + WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x19148b4a // movq (%rcx,%r11), %rdx + WORD $0x6348; BYTE $0xda // movslq %edx, %rbx + WORD $0x2949; BYTE $0xd9 // subq %rbx, %r9 + LONG $0x01228c0f; WORD $0x0000 // jl LBB11_58, $290(%rip) + LONG $0x20e2c148 // shlq $32, %rdx + LONG $0x19148d4e // leaq (%rcx,%r11), %r10 + LONG $0x08c28349 // addq $8, %r10 + QUAD $0x000300000001b948; WORD $0x0000 // movabsq $12884901889, %rcx + WORD $0x3948; BYTE $0xca // cmpq %rcx, %rdx + LONG $0x00278c0f; WORD $0x0000 // jl LBB11_62, $39(%rip) + WORD $0x8b41; BYTE $0x0a // movl (%r10), %ecx + WORD $0x8941; BYTE $0x0e // movl %ecx, (%r14) + LONG $0x04c28349 // addq $4, %r10 + LONG $0x04468d4d // leaq $4(%r14), %r8 + LONG $0xfc4b8d48 // leaq $-4(%rbx), %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x001b830f; WORD $0x0000 // jae LBB11_65, $27(%rip) + LONG $0x00002ae9; BYTE $0x00 // jmp LBB11_66, $42(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB11_62: + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x0014820f; WORD $0x0000 // jb LBB11_66, $20(%rip) + +LBB11_65: + LONG $0x12b70f41 // movzwl (%r10), %edx + LONG $0x10894166 // movw %dx, (%r8) + LONG $0x02c28349 // addq $2, %r10 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec18348 // addq $-2, %rcx + +LBB11_66: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0007840f; WORD $0x0000 // je LBB11_68, $7(%rip) + LONG $0x0ab60f41 // movzbl (%r10), %ecx + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + +LBB11_68: + WORD $0x0149; BYTE $0xde // addq %rbx, %r14 + +LBB11_69: + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx + WORD $0x8949; BYTE $0xc4 // movq %rax, %r12 + LONG $0x01fe8348 // cmpq $1, %rsi + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0xfc02870f; WORD $0xffff // ja LBB11_2, $-1022(%rip) + LONG $0x000076e9; BYTE $0x00 // jmp LBB11_70, $118(%rip) + +LBB11_53: + LONG $0x03fe8348 // cmpq $3, %rsi + LONG $0x002c820f; WORD $0x0000 // jb LBB11_59, $44(%rip) + LONG $0x247c8041; WORD $0x8001 // cmpb $-128, $1(%r12) + LONG $0x0020850f; WORD $0x0000 // jne LBB11_59, $32(%rip) + LONG $0x4cb60f41; WORD $0x0224 // movzbl $2(%r12), %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xfe24 // andb $-2, %al + WORD $0xa83c // cmpb $-88, %al + LONG $0x000e850f; WORD $0x0000 // jne LBB11_59, $14(%rip) + LONG $0x24448d49; BYTE $0x02 // leaq $2(%r12), %rax + LONG $0xfec68348 // addq $-2, %rsi + LONG $0xffff1ae9; BYTE $0xff // jmp LBB11_57, $-230(%rip) + +LBB11_59: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x00558e0f; WORD $0x0000 // jle LBB11_3, $85(%rip) + LONG $0xe206c641 // movb $-30, (%r14) + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0xff49; BYTE $0xc9 // decq %r9 + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0xffff93e9; BYTE $0xff // jmp LBB11_69, $-109(%rip) + +LBB11_48: + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x014c; BYTE $0xf9 // addq %r15, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + WORD $0x294c; BYTE $0xe7 // subq %r12, %rdi + WORD $0x014c; BYTE $0xff // addq %r15, %rdi + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x00002ae9; BYTE $0x00 // jmp LBB11_71, $42(%rip) + +LBB11_50: + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + +LBB11_70: + LONG $0xd0752b4c // subq $-48(%rbp), %r14 + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x894c; BYTE $0x31 // movq %r14, (%rcx) + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + LONG $0x000014e9; BYTE $0x00 // jmp LBB11_71, $20(%rip) + +LBB11_58: + LONG $0xd0752b4c // subq $-48(%rbp), %r14 + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x30 // movq %r14, (%rax) + +LBB11_3: + WORD $0xf749; BYTE $0xd4 // notq %r12 + WORD $0x0149; BYTE $0xfc // addq %rdi, %r12 + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + +LBB11_71: + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + BYTE $0x90 // .p2align 4, 0x90 + +_atof_eisel_lemire64: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0xfea4868d; WORD $0xffff // leal $-348(%rsi), %eax + LONG $0xfffd483d; BYTE $0xff // cmpl $-696, %eax + LONG $0x0122820f; WORD $0x0000 // jb LBB12_1, $290(%rip) + WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 + WORD $0x8941; BYTE $0xd1 // movl %edx, %r9d + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x000d840f; WORD $0x0000 // je LBB12_4, $13(%rip) + LONG $0xd7bd0f4c // bsrq %rdi, %r10 + LONG $0x3ff28349 // xorq $63, %r10 + LONG $0x000006e9; BYTE $0x00 // jmp LBB12_5, $6(%rip) + +LBB12_4: + LONG $0x0040ba41; WORD $0x0000 // movl $64, %r10d + +LBB12_5: + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xd348; BYTE $0xe7 // shlq %cl, %rdi + LONG $0x015c8e8d; WORD $0x0000 // leal $348(%rsi), %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x3b258d4c; WORD $0x005e; BYTE $0x00 // leaq $24123(%rip), %r12 /* _POW10_M128_TAB(%rip) */ + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x2164f74a; BYTE $0x08 // mulq $8(%rcx,%r12) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x8949; BYTE $0xd3 // movq %rdx, %r11 + WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx + LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx + LONG $0xfffb8148; WORD $0x0001; BYTE $0x00 // cmpq $511, %rbx + LONG $0x0050850f; WORD $0x0000 // jne LBB12_11, $80(%rip) + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + WORD $0xf749; BYTE $0xd6 // notq %r14 + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0x394d; BYTE $0xf7 // cmpq %r14, %r15 + LONG $0x0041860f; WORD $0x0000 // jbe LBB12_13, $65(%rip) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x2124f74a // mulq (%rcx,%r12) + WORD $0x014c; BYTE $0xfa // addq %r15, %rdx + LONG $0x00d38349 // adcq $0, %r11 + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0x37e1c148 // shlq $55, %rcx + LONG $0x0013850f; WORD $0x0000 // jne LBB12_12, $19(%rip) + LONG $0xfffa8348 // cmpq $-1, %rdx + LONG $0x0009850f; WORD $0x0000 // jne LBB12_12, $9(%rip) + WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax + LONG $0x0083870f; WORD $0x0000 // ja LBB12_1, $131(%rip) + +LBB12_12: + WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx + LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx + LONG $0x000003e9; BYTE $0x00 // jmp LBB12_13, $3(%rip) + +LBB12_11: + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + +LBB12_13: + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + LONG $0x3fe8c148 // shrq $63, %rax + WORD $0x488d; BYTE $0x09 // leal $9(%rax), %ecx + WORD $0xd349; BYTE $0xeb // shrq %cl, %r11 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0018850f; WORD $0x0000 // jne LBB12_17, $24(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x000f850f; WORD $0x0000 // jne LBB12_17, $15(%rip) + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + WORD $0xe183; BYTE $0x03 // andl $3, %ecx + WORD $0xf983; BYTE $0x01 // cmpl $1, %ecx + LONG $0x0044840f; WORD $0x0000 // je LBB12_1, $68(%rip) + +LBB12_17: + LONG $0x526ace69; WORD $0x0003 // imull $217706, %esi, %ecx + WORD $0xf9c1; BYTE $0x10 // sarl $16, %ecx + LONG $0x043fc181; WORD $0x0000 // addl $1087, %ecx + WORD $0x6348; BYTE $0xf1 // movslq %ecx, %rsi + WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi + WORD $0x8944; BYTE $0xda // movl %r11d, %edx + WORD $0xe283; BYTE $0x01 // andl $1, %edx + WORD $0x014c; BYTE $0xda // addq %r11, %rdx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x36e9c148 // shrq $54, %rcx + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0x01f98348 // cmpq $1, %rcx + LONG $0x00d88348 // sbbq $0, %rax + LONG $0x01b08d48; WORD $0xfff8; BYTE $0xff // leaq $-2047(%rax), %rsi + LONG $0x02fe8148; WORD $0xfff8; BYTE $0xff // cmpq $-2046, %rsi + LONG $0x000b830f; WORD $0x0000 // jae LBB12_19, $11(%rip) + +LBB12_1: + WORD $0xc031 // xorl %eax, %eax + +LBB12_20: + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB12_19: + LONG $0x01f98348 // cmpq $1, %rcx + WORD $0x02b1 // movb $2, %cl + WORD $0xd980; BYTE $0x00 // sbbb $0, %cl + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + LONG $0x34e0c148 // shlq $52, %rax + QUAD $0xffffffffffffb948; WORD $0x000f // movabsq $4503599627370495, %rcx + WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xfff98341 // cmpl $-1, %r9d + LONG $0xc1450f48 // cmovneq %rcx, %rax + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + WORD $0x01b0 // movb $1, %al + LONG $0xffffb8e9; BYTE $0xff // jmp LBB12_20, $-72(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +_decimal_to_f64: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 + LONG $0x00107f83 // cmpl $0, $16(%rdi) + LONG $0x0021840f; WORD $0x0000 // je LBB13_3, $33(%rip) + LONG $0x14478b41 // movl $20(%r15), %eax + LONG $0x0001363d; BYTE $0x00 // cmpl $310, %eax + LONG $0x001d8e0f; WORD $0x0000 // jle LBB13_4, $29(%rip) + +LBB13_2: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 + LONG $0x000397e9; BYTE $0x00 // jmp LBB13_69, $919(%rip) + +LBB13_3: + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x00038ce9; BYTE $0x00 // jmp LBB13_69, $908(%rip) + +LBB13_4: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xfffeb63d; BYTE $0xff // cmpl $-330, %eax + LONG $0x00088d0f; WORD $0x0000 // jge LBB13_6, $8(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x000376e9; BYTE $0x00 // jmp LBB13_69, $886(%rip) + +LBB13_6: + WORD $0xc085 // testl %eax, %eax + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x00aa8e0f; WORD $0x0000 // jle LBB13_17, $170(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x10358d4c; WORD $0x0088; BYTE $0x00 // leaq $34832(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x000039e9; BYTE $0x00 // jmp LBB13_11, $57(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_8: + LONG $0xffffe5be; BYTE $0xff // movl $-27, %esi + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x000a840f; WORD $0x0000 // je LBB13_10, $10(%rip) + +LBB13_9: + WORD $0xdef7 // negl %esi + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x0053f1e8; BYTE $0x00 // callq _right_shift, $21489(%rip) + +LBB13_10: + WORD $0x0141; BYTE $0xdc // addl %ebx, %r12d + LONG $0x14478b41 // movl $20(%r15), %eax + WORD $0xc085 // testl %eax, %eax + LONG $0x00628e0f; WORD $0x0000 // jle LBB13_17, $98(%rip) + +LBB13_11: + WORD $0xf883; BYTE $0x08 // cmpl $8, %eax + LONG $0xffc9870f; WORD $0xffff // ja LBB13_8, $-55(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0x861c8b41 // movl (%r14,%rax,4), %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xffd7840f; WORD $0xffff // je LBB13_10, $-41(%rip) + WORD $0xde89 // movl %ebx, %esi + WORD $0xdef7 // negl %esi + WORD $0xfe83; BYTE $0xc3 // cmpl $-61, %esi + LONG $0xffc0870f; WORD $0xffff // ja LBB13_9, $-64(%rip) + WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB13_15: + WORD $0x8941; BYTE $0xf6 // movl %esi, %r14d + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi + LONG $0x0053a0e8; BYTE $0x00 // callq _right_shift, $21408(%rip) + LONG $0x3c768d41 // leal $60(%r14), %esi + LONG $0x88fe8341 // cmpl $-120, %r14d + LONG $0xffe2820f; WORD $0xffff // jb LBB13_15, $-30(%rip) + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 + LONG $0xffff85e9; BYTE $0xff // jmp LBB13_9, $-123(%rip) + +LBB13_17: + LONG $0x69358d4c; WORD $0x0087; BYTE $0x00 // leaq $34665(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x000025e9; BYTE $0x00 // jmp LBB13_19, $37(%rip) + +LBB13_23: + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x0012840f; WORD $0x0000 // je LBB13_18, $18(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB13_25: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0xde89 // movl %ebx, %esi + LONG $0x005166e8; BYTE $0x00 // callq _left_shift, $20838(%rip) + LONG $0x14478b41 // movl $20(%r15), %eax + +LBB13_18: + WORD $0x2941; BYTE $0xdc // subl %ebx, %r12d + +LBB13_19: + WORD $0xc085 // testl %eax, %eax + LONG $0x0017880f; WORD $0x0000 // js LBB13_22, $23(%rip) + LONG $0x0032850f; WORD $0x0000 // jne LBB13_26, $50(%rip) + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + WORD $0x3980; BYTE $0x35 // cmpb $53, (%rcx) + LONG $0x000e8c0f; WORD $0x0000 // jl LBB13_24, $14(%rip) + LONG $0x000021e9; BYTE $0x00 // jmp LBB13_26, $33(%rip) + + // .p2align 4, 0x90 +LBB13_22: + WORD $0xf883; BYTE $0xf8 // cmpl $-8, %eax + LONG $0xffb3820f; WORD $0xffff // jb LBB13_23, $-77(%rip) + +LBB13_24: + WORD $0xc189 // movl %eax, %ecx + WORD $0xd9f7 // negl %ecx + LONG $0x8e1c8b41 // movl (%r14,%rcx,4), %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xffb4850f; WORD $0xffff // jne LBB13_25, $-76(%rip) + LONG $0xffffbde9; BYTE $0xff // jmp LBB13_18, $-67(%rip) + +LBB13_26: + LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff // cmpl $-1022, %r12d + LONG $0x00568f0f; WORD $0x0000 // jg LBB13_32, $86(%rip) + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x0075840f; WORD $0x0000 // je LBB13_35, $117(%rip) + LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff // cmpl $-1082, %r12d + LONG $0x0073870f; WORD $0x0000 // ja LBB13_36, $115(%rip) + LONG $0xc1c48141; WORD $0x0003; BYTE $0x00 // addl $961, %r12d + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_30: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi + LONG $0x0052c3e8; BYTE $0x00 // callq _right_shift, $21187(%rip) + LONG $0x3cc48341 // addl $60, %r12d + LONG $0x88fc8341 // cmpl $-120, %r12d + LONG $0xffe5820f; WORD $0xffff // jb LBB13_30, $-27(%rip) + LONG $0x3cc48341 // addl $60, %r12d + LONG $0x000040e9; BYTE $0x00 // jmp LBB13_37, $64(%rip) + +LBB13_32: + LONG $0x00fc8141; WORD $0x0004; BYTE $0x00 // cmpl $1024, %r12d + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 + LONG $0x00088e0f; WORD $0x0000 // jle LBB13_34, $8(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x0001c9e9; BYTE $0x00 // jmp LBB13_69, $457(%rip) + +LBB13_34: + WORD $0xff41; BYTE $0xcc // decl %r12d + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + LONG $0x000026e9; BYTE $0x00 // jmp LBB13_38, $38(%rip) + +LBB13_35: + LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d + LONG $0x000033e9; BYTE $0x00 // jmp LBB13_40, $51(%rip) + +LBB13_36: + LONG $0xfdc48141; WORD $0x0003; BYTE $0x00 // addl $1021, %r12d + +LBB13_37: + WORD $0xf741; BYTE $0xdc // negl %r12d + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x8944; BYTE $0xe6 // movl %r12d, %esi + LONG $0x00525ee8; BYTE $0x00 // callq _right_shift, $21086(%rip) + LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d + +LBB13_38: + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x000d840f; WORD $0x0000 // je LBB13_40, $13(%rip) + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0x000035be; BYTE $0x00 // movl $53, %esi + LONG $0x005050e8; BYTE $0x00 // callq _left_shift, $20560(%rip) + +LBB13_40: + LONG $0x14478b41 // movl $20(%r15), %eax + LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 + WORD $0xf883; BYTE $0x14 // cmpl $20, %eax + LONG $0x014d8f0f; WORD $0x0000 // jg LBB13_68, $333(%rip) + WORD $0xc085 // testl %eax, %eax + LONG $0x00558e0f; WORD $0x0000 // jle LBB13_46, $85(%rip) + LONG $0x10578b41 // movl $16(%r15), %edx + WORD $0xf631 // xorl %esi, %esi + WORD $0xd285 // testl %edx, %edx + WORD $0x4e0f; BYTE $0xd6 // cmovlel %esi, %edx + LONG $0xff488d4c // leaq $-1(%rax), %r9 + WORD $0x3949; BYTE $0xd1 // cmpq %rdx, %r9 + LONG $0xca430f4c // cmovaeq %rdx, %r9 + LONG $0x01418d4d // leaq $1(%r9), %r8 + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_43: + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x002e840f; WORD $0x0000 // je LBB13_47, $46(%rip) + LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x0cbe0f48; BYTE $0x31 // movsbq (%rcx,%rsi), %rcx + LONG $0x79248d4c // leaq (%rcx,%rdi,2), %r12 + LONG $0xd0c48349 // addq $-48, %r12 + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffd7850f; WORD $0xffff // jne LBB13_43, $-41(%rip) + WORD $0x894d; BYTE $0xc1 // movq %r8, %r9 + LONG $0x000006e9; BYTE $0x00 // jmp LBB13_47, $6(%rip) + +LBB13_46: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + +LBB13_47: + WORD $0x3944; BYTE $0xc8 // cmpl %r9d, %eax + LONG $0x00608e0f; WORD $0x0000 // jle LBB13_55, $96(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xce // subl %r9d, %esi + WORD $0x8944; BYTE $0xca // movl %r9d, %edx + WORD $0xd2f7 // notl %edx + WORD $0xc201 // addl %eax, %edx + WORD $0xe683; BYTE $0x07 // andl $7, %esi + LONG $0x001f840f; WORD $0x0000 // je LBB13_52, $31(%rip) + WORD $0xdef7 // negl %esi + WORD $0xff31 // xorl %edi, %edi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB13_50: + WORD $0x014d; BYTE $0xe4 // addq %r12, %r12 + LONG $0xa4248d4f // leaq (%r12,%r12,4), %r12 + WORD $0xcfff // decl %edi + WORD $0xfe39 // cmpl %edi, %esi + LONG $0xffef850f; WORD $0xffff // jne LBB13_50, $-17(%rip) + WORD $0x2941; BYTE $0xf9 // subl %edi, %r9d + +LBB13_52: + WORD $0xfa83; BYTE $0x07 // cmpl $7, %edx + LONG $0x0023820f; WORD $0x0000 // jb LBB13_55, $35(%rip) + WORD $0xc289 // movl %eax, %edx + WORD $0x2944; BYTE $0xca // subl %r9d, %edx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB13_54: + LONG $0x00e4694d; WORD $0xf5e1; BYTE $0x05 // imulq $100000000, %r12, %r12 + WORD $0xc283; BYTE $0xf8 // addl $-8, %edx + LONG $0xfff0850f; WORD $0xffff // jne LBB13_54, $-16(%rip) + +LBB13_55: + WORD $0xc085 // testl %eax, %eax + LONG $0x004b880f; WORD $0x0000 // js LBB13_62, $75(%rip) + LONG $0x10578b41 // movl $16(%r15), %edx + WORD $0xc239 // cmpl %eax, %edx + LONG $0x003f8e0f; WORD $0x0000 // jle LBB13_62, $63(%rip) + WORD $0x8b49; BYTE $0x37 // movq (%r15), %rsi + LONG $0x060cb60f // movzbl (%rsi,%rax), %ecx + WORD $0xf980; BYTE $0x35 // cmpb $53, %cl + LONG $0x00af850f; WORD $0x0000 // jne LBB13_64, $175(%rip) + WORD $0x788d; BYTE $0x01 // leal $1(%rax), %edi + WORD $0xd739 // cmpl %edx, %edi + LONG $0x00a4850f; WORD $0x0000 // jne LBB13_64, $164(%rip) + WORD $0x01b2 // movb $1, %dl + LONG $0x1c7f8341; BYTE $0x00 // cmpl $0, $28(%r15) + LONG $0x0019850f; WORD $0x0000 // jne LBB13_65, $25(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x000e840f; WORD $0x0000 // je LBB13_62, $14(%rip) + WORD $0xc8ff // decl %eax + LONG $0x0614b60f // movzbl (%rsi,%rax), %edx + WORD $0xe280; BYTE $0x01 // andb $1, %dl + LONG $0x000002e9; BYTE $0x00 // jmp LBB13_65, $2(%rip) + +LBB13_62: + WORD $0xd231 // xorl %edx, %edx + +LBB13_65: + WORD $0xb60f; BYTE $0xc2 // movzbl %dl, %eax + WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 + QUAD $0x000000000000b848; WORD $0x0020 // movabsq $9007199254740992, %rax + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0x0013850f; WORD $0x0000 // jne LBB13_68, $19(%rip) + LONG $0xfefe8141; WORD $0x0003; BYTE $0x00 // cmpl $1022, %r14d + LONG $0xfc7c8f0f; WORD $0xffff // jg LBB13_2, $-900(%rip) + WORD $0xff41; BYTE $0xc6 // incl %r14d + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + +LBB13_68: + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + WORD $0x214c; BYTE $0xe8 // andq %r13, %rax + LONG $0xffc68141; WORD $0x0003; BYTE $0x00 // addl $1023, %r14d + LONG $0xffe68141; WORD $0x0007; BYTE $0x00 // andl $2047, %r14d + LONG $0x34e6c149 // shlq $52, %r14 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xf0440f4c // cmoveq %rax, %r14 + +LBB13_69: + WORD $0xff49; BYTE $0xcd // decq %r13 + WORD $0x214d; BYTE $0xe5 // andq %r12, %r13 + WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 + QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax + WORD $0x094c; BYTE $0xe8 // orq %r13, %rax + LONG $0x187f8341; BYTE $0x00 // cmpl $0, $24(%r15) + LONG $0xc5440f49 // cmoveq %r13, %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + WORD $0xc031 // xorl %eax, %eax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB13_64: + WORD $0xf980; BYTE $0x35 // cmpb $53, %cl + WORD $0x9d0f; BYTE $0xc2 // setge %dl + LONG $0xffff77e9; BYTE $0xff // jmp LBB13_65, $-137(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +_atof_native: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x28ec8348 // subq $40, %rsp + QUAD $0x00000000d045c748 // movq $0, $-48(%rbp) + LONG $0xb0558948 // movq %rdx, $-80(%rbp) + LONG $0xb84d8948 // movq %rcx, $-72(%rbp) + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0126840f; WORD $0x0000 // je LBB14_18, $294(%rip) + LONG $0x08f98348 // cmpq $8, %rcx + LONG $0x0007830f; WORD $0x0000 // jae LBB14_3, $7(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x000105e9; BYTE $0x00 // jmp LBB14_17, $261(%rip) + +LBB14_3: + LONG $0x20f98348 // cmpq $32, %rcx + LONG $0x0007830f; WORD $0x0000 // jae LBB14_5, $7(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x0000bee9; BYTE $0x00 // jmp LBB14_14, $190(%rip) + +LBB14_5: + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0xe0e38348 // andq $-32, %rbx + LONG $0xe0438d48 // leaq $-32(%rbx), %rax + WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 + LONG $0x05e9c149 // shrq $5, %r9 + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0x8945; BYTE $0xc8 // movl %r9d, %r8d + LONG $0x03e08341 // andl $3, %r8d + LONG $0x60f88348 // cmpq $96, %rax + LONG $0x0007830f; WORD $0x0000 // jae LBB14_7, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + LONG $0x00004ce9; BYTE $0x00 // jmp LBB14_9, $76(%rip) + +LBB14_7: + LONG $0xfce18349 // andq $-4, %r9 + WORD $0xc031 // xorl %eax, %eax + WORD $0x570f; BYTE $0xc0 // xorps %xmm0, %xmm0 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB14_8: + LONG $0x0204110f // movups %xmm0, (%rdx,%rax) + LONG $0x0244110f; BYTE $0x10 // movups %xmm0, $16(%rdx,%rax) + LONG $0x0244110f; BYTE $0x20 // movups %xmm0, $32(%rdx,%rax) + LONG $0x0244110f; BYTE $0x30 // movups %xmm0, $48(%rdx,%rax) + LONG $0x0244110f; BYTE $0x40 // movups %xmm0, $64(%rdx,%rax) + LONG $0x0244110f; BYTE $0x50 // movups %xmm0, $80(%rdx,%rax) + LONG $0x0244110f; BYTE $0x60 // movups %xmm0, $96(%rdx,%rax) + LONG $0x0244110f; BYTE $0x70 // movups %xmm0, $112(%rdx,%rax) + LONG $0x80e88348 // subq $-128, %rax + LONG $0xfcc18349 // addq $-4, %r9 + LONG $0xffcb850f; WORD $0xffff // jne LBB14_8, $-53(%rip) + +LBB14_9: + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x002a840f; WORD $0x0000 // je LBB14_12, $42(%rip) + LONG $0x100c8d4c // leaq (%rax,%rdx), %r9 + LONG $0x10c18349 // addq $16, %r9 + LONG $0x05e0c149 // shlq $5, %r8 + WORD $0xc031 // xorl %eax, %eax + WORD $0x570f; BYTE $0xc0 // xorps %xmm0, %xmm0 + BYTE $0x90 // .p2align 4, 0x90 + +LBB14_11: + LONG $0x44110f41; WORD $0xf001 // movups %xmm0, $-16(%r9,%rax) + LONG $0x04110f41; BYTE $0x01 // movups %xmm0, (%r9,%rax) + LONG $0x20c08348 // addq $32, %rax + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0xffe8850f; WORD $0xffff // jne LBB14_11, $-24(%rip) + +LBB14_12: + WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx + LONG $0x004f840f; WORD $0x0000 // je LBB14_18, $79(%rip) + WORD $0xc1f6; BYTE $0x18 // testb $24, %cl + LONG $0x0036840f; WORD $0x0000 // je LBB14_17, $54(%rip) + +LBB14_14: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0xf8e38348 // andq $-8, %rbx + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB14_15: + QUAD $0x000000000204c748 // movq $0, (%rdx,%rax) + LONG $0x08c08348 // addq $8, %rax + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0xffeb850f; WORD $0xffff // jne LBB14_15, $-21(%rip) + WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx + LONG $0x0012840f; WORD $0x0000 // je LBB14_18, $18(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +LBB14_17: + LONG $0x001a04c6 // movb $0, (%rdx,%rbx) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx + LONG $0xfff0850f; WORD $0xffff // jne LBB14_17, $-16(%rip) + +LBB14_18: + LONG $0x00c045c7; WORD $0x0000; BYTE $0x00 // movl $0, $-64(%rbp) + QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3f80; BYTE $0x2d // cmpb $45, (%rdi) + LONG $0x001b850f; WORD $0x0000 // jne LBB14_19, $27(%rip) + LONG $0x01c845c7; WORD $0x0000; BYTE $0x00 // movl $1, $-56(%rbp) + LONG $0x0001bd41; WORD $0x0000 // movl $1, %r13d + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0x00118c0f; WORD $0x0000 // jl LBB14_22, $17(%rip) + LONG $0x0001b6e9; BYTE $0x00 // jmp LBB14_54, $438(%rip) + +LBB14_19: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0x01aa8d0f; WORD $0x0000 // jge LBB14_54, $426(%rip) + +LBB14_22: + WORD $0xb741; BYTE $0x01 // movb $1, %r15b + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x000028e9; BYTE $0x00 // jmp LBB14_23, $40(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB14_33: + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x8945; BYTE $0xdc // movl %r11d, %r12d + WORD $0x2e3c // cmpb $46, %al + LONG $0x0095850f; WORD $0x0000 // jne LBB14_36, $149(%rip) + +LBB14_34: + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 + LONG $0xc79c0f41 // setl %r15b + LONG $0x007c840f; WORD $0x0000 // je LBB14_35, $124(%rip) + +LBB14_23: + WORD $0x8941; BYTE $0xda // movl %ebx, %r10d + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + LONG $0x04b60f42; BYTE $0x2f // movzbl (%rdi,%r13), %eax + WORD $0x588d; BYTE $0xd0 // leal $-48(%rax), %ebx + WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl + LONG $0xffc9870f; WORD $0xffff // ja LBB14_33, $-55(%rip) + WORD $0x303c // cmpb $48, %al + LONG $0x0021850f; WORD $0x0000 // jne LBB14_29, $33(%rip) + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x0043840f; WORD $0x0000 // je LBB14_26, $67(%rip) + WORD $0x6349; BYTE $0xd8 // movslq %r8d, %rbx + WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx + LONG $0x0018820f; WORD $0x0000 // jb LBB14_32, $24(%rip) + LONG $0x000019e9; BYTE $0x00 // jmp LBB14_28, $25(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB14_29: + WORD $0x6349; BYTE $0xdb // movslq %r11d, %rbx + WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx + LONG $0x0014830f; WORD $0x0000 // jae LBB14_30, $20(%rip) + +LBB14_32: + WORD $0x0488; BYTE $0x1a // movb %al, (%rdx,%rbx) + WORD $0xff41; BYTE $0xc0 // incl %r8d + +LBB14_28: + WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d + WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d + WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx + LONG $0xffff90e9; BYTE $0xff // jmp LBB14_34, $-112(%rip) + +LBB14_30: + LONG $0x0001b941; WORD $0x0000 // movl $1, %r9d + LONG $0x000006e9; BYTE $0x00 // jmp LBB14_31, $6(%rip) + +LBB14_26: + WORD $0xff41; BYTE $0xce // decl %r14d + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + +LBB14_31: + WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d + WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx + LONG $0xffff74e9; BYTE $0xff // jmp LBB14_34, $-140(%rip) + +LBB14_35: + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 + WORD $0x8941; BYTE $0xda // movl %ebx, %r10d + +LBB14_36: + LONG $0xc4758944 // movl %r14d, $-60(%rbp) + LONG $0xcc4d8944 // movl %r9d, $-52(%rbp) + LONG $0xc0458944 // movl %r8d, $-64(%rbp) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0012840f; WORD $0x0000 // je LBB14_37, $18(%rip) + WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d + LONG $0x01c7f641 // testb $1, %r15b + LONG $0x0013850f; WORD $0x0000 // jne LBB14_40, $19(%rip) + LONG $0x0000c4e9; BYTE $0x00 // jmp LBB14_55, $196(%rip) + +LBB14_37: + LONG $0xc4458944 // movl %r8d, $-60(%rbp) + LONG $0x01c7f641 // testb $1, %r15b + LONG $0x00b6840f; WORD $0x0000 // je LBB14_55, $182(%rip) + +LBB14_40: + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0xc983; BYTE $0x20 // orl $32, %ecx + WORD $0xf983; BYTE $0x65 // cmpl $101, %ecx + LONG $0x00a3850f; WORD $0x0000 // jne LBB14_55, $163(%rip) + LONG $0x0754b60f; BYTE $0x01 // movzbl $1(%rdi,%rax), %edx + WORD $0xfa83; BYTE $0x2d // cmpl $45, %edx + LONG $0x0017840f; WORD $0x0000 // je LBB14_45, $23(%rip) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + WORD $0xfa83; BYTE $0x2b // cmpl $43, %edx + LONG $0x0028850f; WORD $0x0000 // jne LBB14_43, $40(%rip) + LONG $0x02c58341 // addl $2, %r13d + LONG $0x000009e9; BYTE $0x00 // jmp LBB14_46, $9(%rip) + +LBB14_45: + LONG $0x02c58341 // addl $2, %r13d + LONG $0xffffffb9; BYTE $0xff // movl $-1, %ecx + +LBB14_46: + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x00168c0f; WORD $0x0000 // jl LBB14_48, $22(%rip) + LONG $0x000055e9; BYTE $0x00 // jmp LBB14_53, $85(%rip) + +LBB14_43: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x00448d0f; WORD $0x0000 // jge LBB14_53, $68(%rip) + +LBB14_48: + WORD $0xc031 // xorl %eax, %eax + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB14_49: + LONG $0x171cbe0f // movsbl (%rdi,%rdx), %ebx + WORD $0xfb83; BYTE $0x30 // cmpl $48, %ebx + LONG $0x00298c0f; WORD $0x0000 // jl LBB14_53, $41(%rip) + WORD $0xfb80; BYTE $0x39 // cmpb $57, %bl + LONG $0x0020870f; WORD $0x0000 // ja LBB14_53, $32(%rip) + LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax + LONG $0x00158f0f; WORD $0x0000 // jg LBB14_53, $21(%rip) + WORD $0x048d; BYTE $0x80 // leal (%rax,%rax,4), %eax + WORD $0x048d; BYTE $0x43 // leal (%rbx,%rax,2), %eax + WORD $0xc083; BYTE $0xd0 // addl $-48, %eax + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffca850f; WORD $0xffff // jne LBB14_49, $-54(%rip) + +LBB14_53: + WORD $0xaf0f; BYTE $0xc1 // imull %ecx, %eax + WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d + +LBB14_54: + LONG $0xc4458944 // movl %r8d, $-60(%rbp) + +LBB14_55: + LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi + LONG $0xd0758d48 // leaq $-48(%rbp), %rsi + LONG $0xfff893e8; BYTE $0xff // callq _decimal_to_f64, $-1901(%rip) + LONG $0x45100ff2; BYTE $0xd0 // movsd $-48(%rbp), %xmm0 + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_value: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x28ec8348 // subq $40, %rsp + WORD $0x894d; BYTE $0xc7 // movq %r8, %r15 + WORD $0x8949; BYTE $0xce // movq %rcx, %r14 + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 + LONG $0xd0558948 // movq %rdx, $-48(%rbp) + LONG $0xb07d8948 // movq %rdi, $-80(%rbp) + LONG $0xb8758948 // movq %rsi, $-72(%rbp) + LONG $0xd0558d48 // leaq $-48(%rbp), %rdx + LONG $0x0005eee8; BYTE $0x00 // callq _advance_ns, $1518(%rip) + WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax + WORD $0xf883; BYTE $0x7d // cmpl $125, %eax + LONG $0x00bc870f; WORD $0x0000 // ja LBB15_11, $188(%rip) + LONG $0x9f0d8d48; WORD $0x0003; BYTE $0x00 // leaq $927(%rip), %rcx /* LJTI15_0(%rip) */ + LONG $0x81046348 // movslq (%rcx,%rax,4), %rax + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + JMP AX + +LBB15_2: + LONG $0xc875894c // movq %r14, $-56(%rbp) + LONG $0xd0758b4c // movq $-48(%rbp), %r14 + LONG $0xff6e8d4d // leaq $-1(%r14), %r13 + LONG $0xd06d894c // movq %r13, $-48(%rbp) + LONG $0x02c7f641 // testb $2, %r15b + LONG $0x001a850f; WORD $0x0000 // jne LBB15_4, $26(%rip) + LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi + LONG $0xd0758d48 // leaq $-48(%rbp), %rsi + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + LONG $0x000e07e8; BYTE $0x00 // callq _vnumber, $3591(%rip) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x00034de9; BYTE $0x00 // jmp LBB15_58, $845(%rip) + +LBB15_4: + WORD $0xc031 // xorl %eax, %eax + LONG $0x2c3c8043; BYTE $0x2d // cmpb $45, (%r12,%r13) + LONG $0x2c3c8d4f // leaq (%r12,%r13), %r15 + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x2948; BYTE $0xc3 // subq %rax, %rbx + LONG $0x030c840f; WORD $0x0000 // je LBB15_53, $780(%rip) + WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 + LONG $0x000e830f; WORD $0x0000 // jae LBB15_7, $14(%rip) + LONG $0x07b60f41 // movzbl (%r15), %eax + WORD $0xc604 // addb $-58, %al + WORD $0xf63c // cmpb $-10, %al + LONG $0x0307820f; WORD $0x0000 // jb LBB15_55, $775(%rip) + +LBB15_7: + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0x001f42e8; BYTE $0x00 // callq _do_skip_number, $8002(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x02ed880f; WORD $0x0000 // js LBB15_54, $749(%rip) + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x02f28e0f; WORD $0x0000 // jle LBB15_57, $754(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + LONG $0x0800c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rax) + LONG $0x1868894c // movq %r13, $24(%rax) + LONG $0x0002e5e9; BYTE $0x00 // jmp LBB15_58, $741(%rip) + +LBB15_10: + LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq $1, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x0002d5e9; BYTE $0x00 // jmp LBB15_58, $725(%rip) + +LBB15_11: + LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + WORD $0xff49; BYTE $0xcf // decq %r15 + LONG $0x0002c2e9; BYTE $0x00 // jmp LBB15_58, $706(%rip) + +LBB15_12: + QUAD $0xffffffffc045c748 // movq $-1, $-64(%rbp) + LONG $0xd0658b4c // movq $-48(%rbp), %r12 + LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi + LONG $0xc0558d48 // leaq $-64(%rbp), %rdx + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + LONG $0x000814e8; BYTE $0x00 // callq _advance_string, $2068(%rip) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0174880f; WORD $0x0000 // js LBB15_32, $372(%rip) + LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0x1066894d // movq %r12, $16(%r14) + LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0xc84c0f48 // cmovlq %rax, %rcx + LONG $0x184e8949 // movq %rcx, $24(%r14) + LONG $0x00026de9; BYTE $0x00 // jmp LBB15_58, $621(%rip) + +LBB15_14: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000bba; BYTE $0x00 // movl $11, %edx + LONG $0x00011ae9; BYTE $0x00 // jmp LBB15_31, $282(%rip) + +LBB15_15: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + LONG $0x000100e9; BYTE $0x00 // jmp LBB15_31, $256(%rip) + +LBB15_16: + LONG $0x0506c749; WORD $0x0000; BYTE $0x00 // movq $5, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x000229e9; BYTE $0x00 // jmp LBB15_58, $553(%rip) + +LBB15_17: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000cba; BYTE $0x00 // movl $12, %edx + LONG $0x0000d6e9; BYTE $0x00 // jmp LBB15_31, $214(%rip) + +LBB15_18: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0xfc4b8d48 // leaq $-4(%rbx), %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x008a870f; WORD $0x0000 // ja LBB15_25, $138(%rip) + LONG $0x3c0c8b43 // movl (%r12,%r15), %ecx + LONG $0x6c61f981; WORD $0x6573 // cmpl $1702063201, %ecx + LONG $0x00d3850f; WORD $0x0000 // jne LBB15_33, $211(%rip) + LONG $0x04c78349 // addq $4, %r15 + LONG $0x000004b8; BYTE $0x00 // movl $4, %eax + LONG $0x000069e9; BYTE $0x00 // jmp LBB15_24, $105(%rip) + +LBB15_21: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x0054870f; WORD $0x0000 // ja LBB15_25, $84(%rip) + LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx + LONG $0x756ef981; WORD $0x6c6c // cmpl $1819047278, %ecx + LONG $0x00db850f; WORD $0x0000 // jne LBB15_37, $219(%rip) + LONG $0x03c78349 // addq $3, %r15 + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + LONG $0x000032e9; BYTE $0x00 // jmp LBB15_24, $50(%rip) + +LBB15_26: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x001d870f; WORD $0x0000 // ja LBB15_25, $29(%rip) + LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx + LONG $0x7274f981; WORD $0x6575 // cmpl $1702195828, %ecx + LONG $0x00e2850f; WORD $0x0000 // jne LBB15_41, $226(%rip) + LONG $0x03c78349 // addq $3, %r15 + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + +LBB15_24: + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + +LBB15_25: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x00015ee9; BYTE $0x00 // jmp LBB15_58, $350(%rip) + +LBB15_29: + LONG $0x0606c749; WORD $0x0000; BYTE $0x00 // movq $6, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x00014ee9; BYTE $0x00 // jmp LBB15_58, $334(%rip) + +LBB15_30: + WORD $0xc031 // xorl %eax, %eax + LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x00000dba; BYTE $0x00 // movl $13, %edx + +LBB15_31: + LONG $0xd1440f48 // cmoveq %rcx, %rdx + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 + LONG $0x000123e9; BYTE $0x00 // jmp LBB15_58, $291(%rip) + +LBB15_32: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x894d; BYTE $0x3e // movq %r15, (%r14) + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x000114e9; BYTE $0x00 // jmp LBB15_58, $276(%rip) + +LBB15_33: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xf980; BYTE $0x61 // cmpb $97, %cl + LONG $0x00d5850f; WORD $0x0000 // jne LBB15_49, $213(%rip) + LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) + LONG $0x00aa850f; WORD $0x0000 // jne LBB15_46, $170(%rip) + LONG $0x3c7c8043; WORD $0x7302 // cmpb $115, $2(%r12,%r15) + LONG $0x00b5850f; WORD $0x0000 // jne LBB15_47, $181(%rip) + LONG $0x044f8d49 // leaq $4(%r15), %rcx + LONG $0x3c7c8043; WORD $0x6503 // cmpb $101, $3(%r12,%r15) + LONG $0x037f8d4d // leaq $3(%r15), %r15 + LONG $0xf9440f4c // cmoveq %rcx, %r15 + LONG $0x0000a2e9; BYTE $0x00 // jmp LBB15_48, $162(%rip) + +LBB15_37: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xf980; BYTE $0x6e // cmpb $110, %cl + LONG $0x006c850f; WORD $0x0000 // jne LBB15_45, $108(%rip) + LONG $0x3c3c8043; BYTE $0x75 // cmpb $117, (%r12,%r15) + LONG $0x0077850f; WORD $0x0000 // jne LBB15_51, $119(%rip) + LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) + LONG $0x0068850f; WORD $0x0000 // jne LBB15_50, $104(%rip) + LONG $0x034f8d49 // leaq $3(%r15), %rcx + LONG $0x3c7c8043; WORD $0x6c02 // cmpb $108, $2(%r12,%r15) + LONG $0x027f8d4d // leaq $2(%r15), %r15 + LONG $0xf9440f4c // cmoveq %rcx, %r15 + LONG $0x000054e9; BYTE $0x00 // jmp LBB15_51, $84(%rip) + +LBB15_41: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xf980; BYTE $0x74 // cmpb $116, %cl + LONG $0x002e850f; WORD $0x0000 // jne LBB15_45, $46(%rip) + LONG $0x3c3c8043; BYTE $0x72 // cmpb $114, (%r12,%r15) + LONG $0x0039850f; WORD $0x0000 // jne LBB15_51, $57(%rip) + LONG $0x3c7c8043; WORD $0x7501 // cmpb $117, $1(%r12,%r15) + LONG $0x002a850f; WORD $0x0000 // jne LBB15_50, $42(%rip) + LONG $0x034f8d49 // leaq $3(%r15), %rcx + LONG $0x3c7c8043; WORD $0x6502 // cmpb $101, $2(%r12,%r15) + LONG $0x027f8d4d // leaq $2(%r15), %r15 + LONG $0xf9440f4c // cmoveq %rcx, %r15 + LONG $0x000016e9; BYTE $0x00 // jmp LBB15_51, $22(%rip) + +LBB15_45: + WORD $0xff49; BYTE $0xcf // decq %r15 + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x00004ee9; BYTE $0x00 // jmp LBB15_58, $78(%rip) + +LBB15_46: + WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0x000013e9; BYTE $0x00 // jmp LBB15_48, $19(%rip) + +LBB15_50: + WORD $0xff49; BYTE $0xc7 // incq %r15 + +LBB15_51: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x000037e9; BYTE $0x00 // jmp LBB15_58, $55(%rip) + +LBB15_47: + LONG $0x02c78349 // addq $2, %r15 + +LBB15_48: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + +LBB15_49: + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x000027e9; BYTE $0x00 // jmp LBB15_58, $39(%rip) + +LBB15_53: + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + LONG $0x00000de9; BYTE $0x00 // jmp LBB15_56, $13(%rip) + +LBB15_54: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + +LBB15_55: + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + +LBB15_56: + WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + LONG $0xd07d894c // movq %r15, $-48(%rbp) + +LBB15_57: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) + +LBB15_58: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90 + + // .set L15_0_set_10, LBB15_10-LJTI15_0 + // .set L15_0_set_11, LBB15_11-LJTI15_0 + // .set L15_0_set_12, LBB15_12-LJTI15_0 + // .set L15_0_set_14, LBB15_14-LJTI15_0 + // .set L15_0_set_2, LBB15_2-LJTI15_0 + // .set L15_0_set_15, LBB15_15-LJTI15_0 + // .set L15_0_set_16, LBB15_16-LJTI15_0 + // .set L15_0_set_17, LBB15_17-LJTI15_0 + // .set L15_0_set_18, LBB15_18-LJTI15_0 + // .set L15_0_set_21, LBB15_21-LJTI15_0 + // .set L15_0_set_26, LBB15_26-LJTI15_0 + // .set L15_0_set_29, LBB15_29-LJTI15_0 + // .set L15_0_set_30, LBB15_30-LJTI15_0 +LJTI15_0: + LONG $0xfffffd06 // .long L15_0_set_10 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd29 // .long L15_0_set_12 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd7e // .long L15_0_set_14 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffc6a // .long L15_0_set_2 + LONG $0xfffffd98 // .long L15_0_set_15 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffdb2 // .long L15_0_set_16 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffdc2 // .long L15_0_set_17 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffddc // .long L15_0_set_18 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe12 // .long L15_0_set_21 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe49 // .long L15_0_set_26 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe8d // .long L15_0_set_29 + LONG $0xfffffd16 // .long L15_0_set_11 + LONG $0xfffffe9d // .long L15_0_set_30 + LONG $0x00000000 // .p2align 4, 0x00 + +LCPI16_0: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + +LCPI16_1: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI16_2: + QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' + +LCPI16_3: + QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + + // .p2align 4, 0x90 +_advance_ns: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8b4c; BYTE $0x02 // movq (%rdx), %r8 + WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 + LONG $0x0029830f; WORD $0x0000 // jae LBB16_6, $41(%rip) + LONG $0x04b60f42; BYTE $0x07 // movzbl (%rdi,%r8), %eax + WORD $0xf883; BYTE $0x0d // cmpl $13, %eax + LONG $0x001b840f; WORD $0x0000 // je LBB16_6, $27(%rip) + WORD $0xf883; BYTE $0x20 // cmpl $32, %eax + LONG $0x0012840f; WORD $0x0000 // je LBB16_6, $18(%rip) + WORD $0xf504 // addb $-11, %al + WORD $0xfe3c // cmpb $-2, %al + LONG $0x0008830f; WORD $0x0000 // jae LBB16_6, $8(%rip) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x000213e9; BYTE $0x00 // jmp LBB16_5, $531(%rip) + +LBB16_6: + LONG $0x01408d49 // leaq $1(%r8), %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x0022830f; WORD $0x0000 // jae LBB16_10, $34(%rip) + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx + LONG $0x0015840f; WORD $0x0000 // je LBB16_10, $21(%rip) + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x000c840f; WORD $0x0000 // je LBB16_10, $12(%rip) + WORD $0xc180; BYTE $0xf5 // addb $-11, %cl + WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl + LONG $0x01e4820f; WORD $0x0000 // jb LBB16_5, $484(%rip) + +LBB16_10: + LONG $0x02408d49 // leaq $2(%r8), %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x0022830f; WORD $0x0000 // jae LBB16_14, $34(%rip) + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx + LONG $0x0015840f; WORD $0x0000 // je LBB16_14, $21(%rip) + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x000c840f; WORD $0x0000 // je LBB16_14, $12(%rip) + WORD $0xc180; BYTE $0xf5 // addb $-11, %cl + WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl + LONG $0x01b5820f; WORD $0x0000 // jb LBB16_5, $437(%rip) + +LBB16_14: + LONG $0x03408d49 // leaq $3(%r8), %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x0022830f; WORD $0x0000 // jae LBB16_18, $34(%rip) + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx + LONG $0x0015840f; WORD $0x0000 // je LBB16_18, $21(%rip) + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x000c840f; WORD $0x0000 // je LBB16_18, $12(%rip) + WORD $0xc180; BYTE $0xf5 // addb $-11, %cl + WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl + LONG $0x0186820f; WORD $0x0000 // jb LBB16_5, $390(%rip) + +LBB16_18: + LONG $0x04c08349 // addq $4, %r8 + WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 + LONG $0x0159830f; WORD $0x0000 // jae LBB16_19, $345(%rip) + LONG $0x070c8d4e // leaq (%rdi,%r8), %r9 + WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 + WORD $0x294d; BYTE $0xc3 // subq %r8, %r11 + LONG $0x0073840f; WORD $0x0000 // je LBB16_27, $115(%rip) + WORD $0x8944; BYTE $0xc8 // movl %r9d, %eax + WORD $0xe083; BYTE $0x0f // andl $15, %eax + LONG $0x0067840f; WORD $0x0000 // je LBB16_27, $103(%rip) + LONG $0x0005ba41; WORD $0x0000 // movl $5, %r10d + WORD $0x2949; BYTE $0xf2 // subq %rsi, %r10 + QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB16_23: + LONG $0x0cbe0f42; BYTE $0x07 // movsbl (%rdi,%r8), %ecx + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x0122870f; WORD $0x0000 // ja LBB16_42, $290(%rip) + LONG $0xc9a30f49 // btq %rcx, %r9 + LONG $0x0118830f; WORD $0x0000 // jae LBB16_42, $280(%rip) + LONG $0x02048d4b // leaq (%r10,%r8), %rax + LONG $0x01488d49 // leaq $1(%r8), %rcx + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x0012840f; WORD $0x0000 // je LBB16_26, $18(%rip) + LONG $0x07048d42 // leal (%rdi,%r8), %eax + WORD $0xc0ff // incl %eax + WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 + WORD $0xe083; BYTE $0x0f // andl $15, %eax + LONG $0xffc4850f; WORD $0xffff // jne LBB16_23, $-60(%rip) + +LBB16_26: + LONG $0x0f0c8d4c // leaq (%rdi,%rcx), %r9 + WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 + WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 + +LBB16_27: + LONG $0x10fb8349 // cmpq $16, %r11 + LONG $0x0081820f; WORD $0x0000 // jb LBB16_33, $129(%rip) + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + WORD $0x294c; BYTE $0xc9 // subq %r9, %rcx + QUAD $0xfffffe52056f0f66 // movdqa $-430(%rip), %xmm0 /* LCPI16_0(%rip) */ + QUAD $0xfffffe5a0d6f0f66 // movdqa $-422(%rip), %xmm1 /* LCPI16_1(%rip) */ + QUAD $0xfffffe62156f0f66 // movdqa $-414(%rip), %xmm2 /* LCPI16_2(%rip) */ + QUAD $0xfffffe6a1d6f0f66 // movdqa $-406(%rip), %xmm3 /* LCPI16_3(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB16_29: + LONG $0x6f0f4166; BYTE $0x21 // movdqa (%r9), %xmm4 + LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 + LONG $0xe8740f66 // pcmpeqb %xmm0, %xmm5 + LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 + LONG $0xf1740f66 // pcmpeqb %xmm1, %xmm6 + LONG $0xf5eb0f66 // por %xmm5, %xmm6 + LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 + LONG $0xea740f66 // pcmpeqb %xmm2, %xmm5 + LONG $0xe3740f66 // pcmpeqb %xmm3, %xmm4 + LONG $0xe5eb0f66 // por %xmm5, %xmm4 + LONG $0xe6eb0f66 // por %xmm6, %xmm4 + LONG $0xc4d70f66 // pmovmskb %xmm4, %eax + LONG $0xfff88366 // cmpw $-1, %ax + LONG $0x0069850f; WORD $0x0000 // jne LBB16_30, $105(%rip) + LONG $0x10c18349 // addq $16, %r9 + LONG $0xf0c38349 // addq $-16, %r11 + LONG $0xf0c18348 // addq $-16, %rcx + LONG $0x0ffb8349 // cmpq $15, %r11 + LONG $0xffaf870f; WORD $0xffff // ja LBB16_29, $-81(%rip) + +LBB16_33: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0037840f; WORD $0x0000 // je LBB16_40, $55(%rip) + LONG $0x19048d4f // leaq (%r9,%r11), %r8 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x000100002600ba49; WORD $0x0000 // movabsq $4294977024, %r10 + +LBB16_35: + LONG $0x04be0f41; BYTE $0x09 // movsbl (%r9,%rcx), %eax + WORD $0xf883; BYTE $0x20 // cmpl $32, %eax + LONG $0x005b870f; WORD $0x0000 // ja LBB16_37, $91(%rip) + LONG $0xc2a30f49 // btq %rax, %r10 + LONG $0x0051830f; WORD $0x0000 // jae LBB16_37, $81(%rip) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 + LONG $0xffdc850f; WORD $0xffff // jne LBB16_35, $-36(%rip) + WORD $0x894d; BYTE $0xc1 // movq %r8, %r9 + +LBB16_40: + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + +LBB16_41: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + LONG $0x000014e9; BYTE $0x00 // jmp LBB16_42, $20(%rip) + +LBB16_19: + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + LONG $0x000028e9; BYTE $0x00 // jmp LBB16_43, $40(%rip) + +LBB16_30: + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0xd0f7 // notl %eax + LONG $0xc0bc0f44 // bsfl %eax, %r8d + WORD $0x2949; BYTE $0xc8 // subq %rcx, %r8 + +LBB16_42: + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 + LONG $0x0010830f; WORD $0x0000 // jae LBB16_43, $16(%rip) + +LBB16_5: + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x0704b60f // movzbl (%rdi,%rax), %eax + WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB16_43: + WORD $0xc031 // xorl %eax, %eax + WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB16_37: + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + LONG $0xffffb6e9; BYTE $0xff // jmp LBB16_41, $-74(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +_vstring: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x10ec8348 // subq $16, %rsp + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + QUAD $0xffffffffd845c748 // movq $-1, $-40(%rbp) + WORD $0x8b4c; BYTE $0x26 // movq (%rsi), %r12 + LONG $0xd8558d48 // leaq $-40(%rbp), %rdx + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0x000081e8; BYTE $0x00 // callq _advance_string, $129(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0029880f; WORD $0x0000 // js LBB17_1, $41(%rip) + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0x1066894d // movq %r12, $16(%r14) + LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) + LONG $0xd84d8b48 // movq $-40(%rbp), %rcx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xc14c0f48 // cmovlq %rcx, %rax + LONG $0x18468949 // movq %rax, $24(%r14) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB17_3, $10(%rip) + +LBB17_1: + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + +LBB17_3: + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +LCPI18_0: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI18_1: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI18_2: + QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' + + // .p2align 4, 0x90 +_advance_string: + WORD $0xc1f6; BYTE $0x20 // testb $32, %cl + LONG $0x0005850f; WORD $0x0000 // jne LBB18_2, $5(%rip) + LONG $0x0045a2e9; BYTE $0x00 // jmp _advance_string_default, $17826(%rip) + +LBB18_2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x18ec8348 // subq $24, %rsp + LONG $0x087f8b4c // movq $8(%rdi), %r15 + WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 + LONG $0x04c3840f; WORD $0x0000 // je LBB18_47, $1219(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + LONG $0xd0458948 // movq %rax, $-48(%rbp) + LONG $0xc0558948 // movq %rdx, $-64(%rbp) + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + LONG $0x40ff8349 // cmpq $64, %r15 + LONG $0x03d0820f; WORD $0x0000 // jb LBB18_48, $976(%rip) + QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + QUAD $0xffff74056f0f4466; BYTE $0xff // movdqa $-140(%rip), %xmm8 /* LCPI18_0(%rip) */ + QUAD $0xffff7b0d6f0f4466; BYTE $0xff // movdqa $-133(%rip), %xmm9 /* LCPI18_1(%rip) */ + QUAD $0xffff82156f0f4466; BYTE $0xff // movdqa $-126(%rip), %xmm10 /* LCPI18_2(%rip) */ + WORD $0x9090 // .p2align 4, 0x90 + +LBB18_5: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + LONG $0x1c6f0ff3; BYTE $0x30 // movdqu (%rax,%rsi), %xmm3 + LONG $0x446f0ff3; WORD $0x1030 // movdqu $16(%rax,%rsi), %xmm0 + LONG $0x4c6f0ff3; WORD $0x2030 // movdqu $32(%rax,%rsi), %xmm1 + LONG $0x546f0ff3; WORD $0x3030 // movdqu $48(%rax,%rsi), %xmm2 + LONG $0xfb6f0f66 // movdqa %xmm3, %xmm7 + LONG $0x740f4166; BYTE $0xf8 // pcmpeqb %xmm8, %xmm7 + LONG $0xd70f4466; BYTE $0xe7 // pmovmskb %xmm7, %r12d + LONG $0xf86f0f66 // movdqa %xmm0, %xmm7 + LONG $0xf06f0f66 // movdqa %xmm0, %xmm6 + LONG $0xda0f4166; BYTE $0xf2 // pminub %xmm10, %xmm6 + LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 + LONG $0x740f4166; BYTE $0xc0 // pcmpeqb %xmm8, %xmm0 + LONG $0xd70f4466; BYTE $0xc0 // pmovmskb %xmm0, %r8d + LONG $0xc16f0f66 // movdqa %xmm1, %xmm0 + LONG $0xe96f0f66 // movdqa %xmm1, %xmm5 + LONG $0xda0f4166; BYTE $0xea // pminub %xmm10, %xmm5 + LONG $0xe9740f66 // pcmpeqb %xmm1, %xmm5 + LONG $0x740f4166; BYTE $0xc8 // pcmpeqb %xmm8, %xmm1 + LONG $0xd70f4466; BYTE $0xc9 // pmovmskb %xmm1, %r9d + LONG $0xca6f0f66 // movdqa %xmm2, %xmm1 + LONG $0xe26f0f66 // movdqa %xmm2, %xmm4 + LONG $0xda0f4166; BYTE $0xe2 // pminub %xmm10, %xmm4 + LONG $0xe2740f66 // pcmpeqb %xmm2, %xmm4 + LONG $0x740f4166; BYTE $0xd0 // pcmpeqb %xmm8, %xmm2 + LONG $0xd70f4466; BYTE $0xd2 // pmovmskb %xmm2, %r10d + LONG $0xd36f0f66 // movdqa %xmm3, %xmm2 + LONG $0x740f4166; BYTE $0xd1 // pcmpeqb %xmm9, %xmm2 + LONG $0xd70f4466; BYTE $0xea // pmovmskb %xmm2, %r13d + LONG $0x740f4166; BYTE $0xf9 // pcmpeqb %xmm9, %xmm7 + LONG $0xcfd70f66 // pmovmskb %xmm7, %ecx + LONG $0x740f4166; BYTE $0xc1 // pcmpeqb %xmm9, %xmm0 + LONG $0xd70f4466; BYTE $0xd8 // pmovmskb %xmm0, %r11d + LONG $0x740f4166; BYTE $0xc9 // pcmpeqb %xmm9, %xmm1 + LONG $0xd1d70f66 // pmovmskb %xmm1, %edx + LONG $0xded70f66 // pmovmskb %xmm6, %ebx + LONG $0xc5d70f66 // pmovmskb %xmm5, %eax + LONG $0xfcd70f66 // pmovmskb %xmm4, %edi + LONG $0x30e2c149 // shlq $48, %r10 + LONG $0x20e1c149 // shlq $32, %r9 + WORD $0x094d; BYTE $0xd1 // orq %r10, %r9 + LONG $0x10e0c149 // shlq $16, %r8 + WORD $0x094d; BYTE $0xc8 // orq %r9, %r8 + WORD $0x094d; BYTE $0xc4 // orq %r8, %r12 + LONG $0x30e2c148 // shlq $48, %rdx + LONG $0x20e3c149 // shlq $32, %r11 + WORD $0x0949; BYTE $0xd3 // orq %rdx, %r11 + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x094c; BYTE $0xd9 // orq %r11, %rcx + LONG $0x30e7c148 // shlq $48, %rdi + LONG $0x20e0c148 // shlq $32, %rax + WORD $0x0948; BYTE $0xf8 // orq %rdi, %rax + LONG $0x10e3c148 // shlq $16, %rbx + WORD $0x0948; BYTE $0xc3 // orq %rax, %rbx + WORD $0x0949; BYTE $0xcd // orq %rcx, %r13 + LONG $0x0049850f; WORD $0x0000 // jne LBB18_11, $73(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x005d850f; WORD $0x0000 // jne LBB18_13, $93(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + +LBB18_8: + LONG $0xc36f0f66 // movdqa %xmm3, %xmm0 + LONG $0xda0f4166; BYTE $0xc2 // pminub %xmm10, %xmm0 + LONG $0xc3740f66 // pcmpeqb %xmm3, %xmm0 + LONG $0xc0d70f66 // pmovmskb %xmm0, %eax + WORD $0x0948; BYTE $0xc3 // orq %rax, %rbx + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x008b850f; WORD $0x0000 // jne LBB18_14, $139(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00d5850f; WORD $0x0000 // jne LBB18_20, $213(%rip) + LONG $0xc0c78349 // addq $-64, %r15 + LONG $0x40c68348 // addq $64, %rsi + LONG $0x3fff8349 // cmpq $63, %r15 + LONG $0xfeca870f; WORD $0xffff // ja LBB18_5, $-310(%rip) + LONG $0x0000e3e9; BYTE $0x00 // jmp LBB18_22, $227(%rip) + +LBB18_11: + LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) + LONG $0x0012850f; WORD $0x0000 // jne LBB18_13, $18(%rip) + LONG $0xcdbc0f49 // bsfq %r13, %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0xc0458b48 // movq $-64(%rbp), %rax + LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + +LBB18_13: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x214c; BYTE $0xe8 // andq %r13, %rax + LONG $0x000c8d48 // leaq (%rax,%rax), %rcx + WORD $0x094c; BYTE $0xf1 // orq %r14, %rcx + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x214c; BYTE $0xea // andq %r13, %rdx + QUAD $0xaaaaaaaaaaaabf48; WORD $0xaaaa // movabsq $-6148914691236517206, %rdi + WORD $0x2148; BYTE $0xfa // andq %rdi, %rdx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0xc6920f41 // setb %r14b + WORD $0x0148; BYTE $0xd2 // addq %rdx, %rdx + QUAD $0x555555555555b848; WORD $0x5555 // movabsq $6148914691236517205, %rax + WORD $0x3148; BYTE $0xc2 // xorq %rax, %rdx + WORD $0x2148; BYTE $0xca // andq %rcx, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x2149; BYTE $0xd4 // andq %rdx, %r12 + LONG $0xffff58e9; BYTE $0xff // jmp LBB18_8, $-168(%rip) + +LBB18_14: + LONG $0xc4bc0f49 // bsfq %r12, %rax + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0022840f; WORD $0x0000 // je LBB18_18, $34(%rip) + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x0023820f; WORD $0x0000 // jb LBB18_19, $35(%rip) + +LBB18_16: + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + +LBB18_17: + LONG $0x18c48348 // addq $24, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB18_18: + LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffdd830f; WORD $0xffff // jae LBB18_16, $-35(%rip) + +LBB18_19: + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xffffcde9; BYTE $0xff // jmp LBB18_17, $-51(%rip) + +LBB18_20: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) + LONG $0xffbb850f; WORD $0xffff // jne LBB18_17, $-69(%rip) + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0xc0558b48 // movq $-64(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0xffffa8e9; BYTE $0xff // jmp LBB18_17, $-88(%rip) + +LBB18_22: + LONG $0xd0750348 // addq $-48(%rbp), %rsi + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x00e1820f; WORD $0x0000 // jb LBB18_35, $225(%rip) + +LBB18_23: + LONG $0x066f0ff3 // movdqu (%rsi), %xmm0 + QUAD $0xfffffd280d6f0f66 // movdqa $-728(%rip), %xmm1 /* LCPI18_0(%rip) */ + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + QUAD $0xfffffd3c1d6f0f66 // movdqa $-708(%rip), %xmm3 /* LCPI18_2(%rip) */ + LONG $0xe06f0f66 // movdqa %xmm0, %xmm4 + LONG $0xe3da0f66 // pminub %xmm3, %xmm4 + LONG $0xe0740f66 // pcmpeqb %xmm0, %xmm4 + LONG $0xc1740f66 // pcmpeqb %xmm1, %xmm0 + LONG $0xc0d70f66 // pmovmskb %xmm0, %eax + LONG $0x466f0ff3; BYTE $0x10 // movdqu $16(%rsi), %xmm0 + LONG $0xc8740f66 // pcmpeqb %xmm0, %xmm1 + LONG $0xc9d70f66 // pmovmskb %xmm1, %ecx + QUAD $0xfffffd030d6f0f66 // movdqa $-765(%rip), %xmm1 /* LCPI18_1(%rip) */ + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xd70f4466; BYTE $0xd2 // pmovmskb %xmm2, %r10d + LONG $0xc8740f66 // pcmpeqb %xmm0, %xmm1 + LONG $0xd1d70f66 // pmovmskb %xmm1, %edx + LONG $0xd70f4466; BYTE $0xcc // pmovmskb %xmm4, %r9d + LONG $0xd8da0f66 // pminub %xmm0, %xmm3 + LONG $0xd8740f66 // pcmpeqb %xmm0, %xmm3 + LONG $0xdbd70f66 // pmovmskb %xmm3, %ebx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0x10e2c148 // shlq $16, %rdx + LONG $0x10e3c148 // shlq $16, %rbx + WORD $0x0949; BYTE $0xd2 // orq %rdx, %r10 + LONG $0x011f850f; WORD $0x0000 // jne LBB18_49, $287(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x013a850f; WORD $0x0000 // jne LBB18_51, $314(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + +LBB18_26: + WORD $0x094c; BYTE $0xcb // orq %r9, %rbx + LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx + LONG $0x000040ba; BYTE $0x00 // movl $64, %edx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0004840f; WORD $0x0000 // je LBB18_28, $4(%rip) + LONG $0xd0bc0f48 // bsfq %rax, %rdx + +LBB18_28: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0004840f; WORD $0x0000 // je LBB18_30, $4(%rip) + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + +LBB18_30: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0019840f; WORD $0x0000 // je LBB18_33, $25(%rip) + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x0135820f; WORD $0x0000 // jb LBB18_52, $309(%rip) + LONG $0xd0752b48 // subq $-48(%rbp), %rsi + LONG $0x16048d48 // leaq (%rsi,%rdx), %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xfffecae9; BYTE $0xff // jmp LBB18_17, $-310(%rip) + +LBB18_33: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x011c850f; WORD $0x0000 // jne LBB18_52, $284(%rip) + LONG $0x20c68348 // addq $32, %rsi + LONG $0xe0c78349 // addq $-32, %r15 + +LBB18_35: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0125850f; WORD $0x0000 // jne LBB18_54, $293(%rip) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xfea0840f; WORD $0xffff // je LBB18_17, $-352(%rip) + +LBB18_37: + LONG $0xc0558b48 // movq $-64(%rbp), %rdx + +LBB18_38: + WORD $0xb60f; BYTE $0x0e // movzbl (%rsi), %ecx + WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx + LONG $0x0063840f; WORD $0x0000 // je LBB18_46, $99(%rip) + WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx + LONG $0x0026840f; WORD $0x0000 // je LBB18_43, $38(%rip) + WORD $0xf980; BYTE $0x1f // cmpb $31, %cl + LONG $0x0143860f; WORD $0x0000 // jbe LBB18_58, $323(%rip) + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0x000001bf; BYTE $0x00 // movl $1, %edi + +LBB18_42: + WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + LONG $0xffca850f; WORD $0xffff // jne LBB18_38, $-54(%rip) + LONG $0xfffe61e9; BYTE $0xff // jmp LBB18_17, $-415(%rip) + +LBB18_43: + LONG $0x01ff8349 // cmpq $1, %r15 + LONG $0xfe57840f; WORD $0xffff // je LBB18_17, $-425(%rip) + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x000002bf; BYTE $0x00 // movl $2, %edi + LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) + LONG $0xffce850f; WORD $0xffff // jne LBB18_42, $-50(%rip) + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + LONG $0xd05d2b48 // subq $-48(%rbp), %rbx + LONG $0xc85d8948 // movq %rbx, $-56(%rbp) + WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) + LONG $0xffffbbe9; BYTE $0xff // jmp LBB18_42, $-69(%rip) + +LBB18_46: + LONG $0xd0752b48 // subq $-48(%rbp), %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0xfffe1ee9; BYTE $0xff // jmp LBB18_17, $-482(%rip) + +LBB18_48: + LONG $0xd0750348 // addq $-48(%rbp), %rsi + QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0xfe6b830f; WORD $0xffff // jae LBB18_23, $-405(%rip) + LONG $0xffff47e9; BYTE $0xff // jmp LBB18_35, $-185(%rip) + +LBB18_49: + LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) + LONG $0x0019850f; WORD $0x0000 // jne LBB18_51, $25(%rip) + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + LONG $0xd04d2b48 // subq $-48(%rbp), %rcx + LONG $0xd2bc0f49 // bsfq %r10, %rdx + WORD $0x0148; BYTE $0xca // addq %rcx, %rdx + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + LONG $0xc8558948 // movq %rdx, $-56(%rbp) + WORD $0x8948; BYTE $0x11 // movq %rdx, (%rcx) + +LBB18_51: + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0x2144; BYTE $0xd1 // andl %r10d, %ecx + WORD $0x148d; BYTE $0x09 // leal (%rcx,%rcx), %edx + LONG $0x4e048d45 // leal (%r14,%rcx,2), %r8d + WORD $0xd2f7 // notl %edx + WORD $0x2144; BYTE $0xd2 // andl %r10d, %edx + LONG $0xaaaae281; WORD $0xaaaa // andl $-1431655766, %edx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0xca01 // addl %ecx, %edx + LONG $0xc6920f41 // setb %r14b + WORD $0xd201 // addl %edx, %edx + LONG $0x5555f281; WORD $0x5555 // xorl $1431655765, %edx + WORD $0x2144; BYTE $0xc2 // andl %r8d, %edx + WORD $0xd2f7 // notl %edx + WORD $0xd021 // andl %edx, %eax + LONG $0xfffe92e9; BYTE $0xff // jmp LBB18_26, $-366(%rip) + +LBB18_52: + LONG $0xd0752b48 // subq $-48(%rbp), %rsi + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + +LBB18_53: + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xfffd8be9; BYTE $0xff // jmp LBB18_17, $-629(%rip) + +LBB18_54: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x003b840f; WORD $0x0000 // je LBB18_47, $59(%rip) + LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) + LONG $0x0015850f; WORD $0x0000 // jne LBB18_57, $21(%rip) + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0xc0458b48 // movq $-64(%rbp), %rax + LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + +LBB18_57: + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff49; BYTE $0xcf // decq %r15 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xfeac850f; WORD $0xffff // jne LBB18_37, $-340(%rip) + LONG $0xfffd47e9; BYTE $0xff // jmp LBB18_17, $-697(%rip) + +LBB18_47: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffd3be9; BYTE $0xff // jmp LBB18_17, $-709(%rip) + +LBB18_58: + LONG $0xd0752b48 // subq $-48(%rbp), %rsi + LONG $0xffff94e9; BYTE $0xff // jmp LBB18_53, $-108(%rip) + QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 + +LCPI19_0: + LONG $0x43300000 // .long 1127219200 + LONG $0x45300000 // .long 1160773632 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + +LCPI19_1: + QUAD $0x4330000000000000 // .quad 0x4330000000000000 + QUAD $0x4530000000000000 // .quad 0x4530000000000000 + + // .p2align 3, 0x00 +LCPI19_2: + QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000 + +LCPI19_3: + QUAD $0xc30c6bf526340000 // .quad 0xc30c6bf526340000 + + // .p2align 4, 0x90 +_vnumber: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x38ec8348 // subq $56, %rsp + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax + WORD $0x8b4c; BYTE $0x3f // movq (%rdi), %r15 + LONG $0x086f8b4c // movq $8(%rdi), %r13 + LONG $0x20528b4c // movq $32(%rdx), %r10 + LONG $0x285a8b4c // movq $40(%rdx), %r11 + LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) + LONG $0xc0570f66 // xorpd %xmm0, %xmm0 + LONG $0x42110f66; BYTE $0x08 // movupd %xmm0, $8(%rdx) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + LONG $0x184a8948 // movq %rcx, $24(%rdx) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x02c9830f; WORD $0x0000 // jae LBB19_51, $713(%rip) + LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx + LONG $0x000001bf; BYTE $0x00 // movl $1, %edi + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl + LONG $0x0016850f; WORD $0x0000 // jne LBB19_4, $22(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x02aa830f; WORD $0x0000 // jae LBB19_51, $682(%rip) + LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx + LONG $0xffffffbf; BYTE $0xff // movl $-1, %edi + +LBB19_4: + WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB19_6, $15(%rip) + +LBB19_5: + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) + LONG $0x00028fe9; BYTE $0x00 // jmp LBB19_52, $655(%rip) + +LBB19_6: + WORD $0xf980; BYTE $0x30 // cmpb $48, %cl + LONG $0x0032850f; WORD $0x0000 // jne LBB19_10, $50(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00a6830f; WORD $0x0000 // jae LBB19_18, $166(%rip) + LONG $0x14b60f41; BYTE $0x0f // movzbl (%r15,%rcx), %edx + WORD $0xc283; BYTE $0xd2 // addl $-46, %edx + WORD $0xfa83; BYTE $0x37 // cmpl $55, %edx + LONG $0x0095870f; WORD $0x0000 // ja LBB19_18, $149(%rip) + QUAD $0x000000800001be48; WORD $0x0080 // movabsq $36028797027352577, %rsi + LONG $0xd6a30f48 // btq %rdx, %rsi + LONG $0x0081830f; WORD $0x0000 // jae LBB19_18, $129(%rip) + +LBB19_10: + WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) + WORD $0x01b1 // movb $1, %cl + WORD $0x4d89; BYTE $0xc8 // movl %ecx, $-56(%rbp) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0063830f; WORD $0x0000 // jae LBB19_17, $99(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x000012e9; BYTE $0x00 // jmp LBB19_13, $18(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB19_12: + WORD $0xc1ff // incl %ecx + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0x0036840f; WORD $0x0000 // je LBB19_16, $54(%rip) + +LBB19_13: + LONG $0x14be0f49; BYTE $0x07 // movsbq (%r15,%rax), %rdx + WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x0041870f; WORD $0x0000 // ja LBB19_19, $65(%rip) + LONG $0x12f88341 // cmpl $18, %r8d + LONG $0xffd68f0f; WORD $0xffff // jg LBB19_12, $-42(%rip) + LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi + WORD $0x0144; BYTE $0xca // addl %r9d, %edx + LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 + WORD $0xff41; BYTE $0xc0 // incl %r8d + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0xffca850f; WORD $0xffff // jne LBB19_13, $-54(%rip) + +LBB19_16: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + LONG $0x00005be9; BYTE $0x00 // jmp LBB19_24, $91(%rip) + +LBB19_17: + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x00004ee9; BYTE $0x00 // jmp LBB19_24, $78(%rip) + +LBB19_18: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x0001cbe9; BYTE $0x00 // jmp LBB19_52, $459(%rip) + +LBB19_19: + WORD $0xfa80; BYTE $0x2e // cmpb $46, %dl + LONG $0x003d850f; WORD $0x0000 // jne LBB19_24, $61(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + WORD $0x394c; BYTE $0xea // cmpq %r13, %rdx + LONG $0x01a4830f; WORD $0x0000 // jae LBB19_51, $420(%rip) + LONG $0x44b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %eax + WORD $0xc604 // addb $-58, %al + WORD $0xf53c // cmpb $-11, %al + LONG $0x000f870f; WORD $0x0000 // ja LBB19_23, $15(%rip) + WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) + LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) + LONG $0x00018fe9; BYTE $0x00 // jmp LBB19_52, $399(%rip) + +LBB19_23: + LONG $0x00c845c7; WORD $0x0000; BYTE $0x00 // movl $0, $-56(%rbp) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + +LBB19_24: + WORD $0xd231 // xorl %edx, %edx + WORD $0xc985 // testl %ecx, %ecx + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x5589; BYTE $0xbc // movl %edx, $-68(%rbp) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x005d850f; WORD $0x0000 // jne LBB19_33, $93(%rip) + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0055850f; WORD $0x0000 // jne LBB19_33, $85(%rip) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0044830f; WORD $0x0000 // jae LBB19_31, $68(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xee // subl %r13d, %esi + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB19_28: + LONG $0x073c8041; BYTE $0x30 // cmpb $48, (%r15,%rax) + LONG $0x0029850f; WORD $0x0000 // jne LBB19_32, $41(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0xc9ff // decl %ecx + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0xffe7850f; WORD $0xffff // jne LBB19_28, $-25(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax + WORD $0xc084 // testb %al, %al + LONG $0x0144850f; WORD $0x0000 // jne LBB19_54, $324(%rip) + +LBB19_59: + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0x000173e9; BYTE $0x00 // jmp LBB19_60, $371(%rip) + +LBB19_31: + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + +LBB19_32: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + +LBB19_33: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x004c830f; WORD $0x0000 // jae LBB19_39, $76(%rip) + LONG $0x12f88341 // cmpl $18, %r8d + LONG $0x00428f0f; WORD $0x0000 // jg LBB19_39, $66(%rip) + LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d + + // .p2align 4, 0x90 +LBB19_36: + LONG $0x14b60f41; BYTE $0x07 // movzbl (%r15,%rax), %edx + WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x002a870f; WORD $0x0000 // ja LBB19_39, $42(%rip) + LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi + WORD $0x0144; BYTE $0xca // addl %r9d, %edx + LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 + WORD $0xc9ff // decl %ecx + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0011830f; WORD $0x0000 // jae LBB19_39, $17(%rip) + LONG $0x01508d41 // leal $1(%r8), %edx + LONG $0x12f88341 // cmpl $18, %r8d + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + LONG $0xffc48c0f; WORD $0xffff // jl LBB19_36, $-60(%rip) + +LBB19_39: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00c6830f; WORD $0x0000 // jae LBB19_53, $198(%rip) + LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x0030870f; WORD $0x0000 // ja LBB19_45, $48(%rip) + LONG $0xff558d49 // leaq $-1(%r13), %rdx + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB19_42: + WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx + LONG $0x0182840f; WORD $0x0000 // je LBB19_58, $386(%rip) + LONG $0x74b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %esi + WORD $0x7e8d; BYTE $0xd0 // leal $-48(%rsi), %edi + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0xffe1860f; WORD $0xffff // jbe LBB19_42, $-31(%rip) + LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) + +LBB19_45: + LONG $0xd6b60f40 // movzbl %sil, %edx + WORD $0xca83; BYTE $0x20 // orl $32, %edx + WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx + LONG $0x0075850f; WORD $0x0000 // jne LBB19_53, $117(%rip) + LONG $0x01788d48 // leaq $1(%rax), %rdi + LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + WORD $0x394c; BYTE $0xef // cmpq %r13, %rdi + LONG $0x0048830f; WORD $0x0000 // jae LBB19_51, $72(%rip) + LONG $0x34b60f41; BYTE $0x3f // movzbl (%r15,%rdi), %esi + WORD $0xfe83; BYTE $0x2d // cmpl $45, %esi + LONG $0x000f840f; WORD $0x0000 // je LBB19_49, $15(%rip) + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + WORD $0xfe83; BYTE $0x2b // cmpl $43, %esi + LONG $0x02ac850f; WORD $0x0000 // jne LBB19_86, $684(%rip) + +LBB19_49: + LONG $0x02c08348 // addq $2, %rax + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0x001b830f; WORD $0x0000 // jae LBB19_51, $27(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x2bfe8040 // cmpb $43, %sil + LONG $0xc7940f40 // sete %dil + LONG $0x3f048d44 // leal (%rdi,%rdi), %r8d + WORD $0xff41; BYTE $0xc8 // decl %r8d + LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi + LONG $0x000287e9; BYTE $0x00 // jmp LBB19_87, $647(%rip) + +LBB19_51: + WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) + LONG $0xff03c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rbx) + +LBB19_52: + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB19_53: + WORD $0xce89 // movl %ecx, %esi + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax + WORD $0xc084 // testb %al, %al + LONG $0xfebc840f; WORD $0xffff // je LBB19_59, $-324(%rip) + +LBB19_54: + WORD $0xf685 // testl %esi, %esi + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0x0025850f; WORD $0x0000 // jne LBB19_57, $37(%rip) + QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax + WORD $0x6348; BYTE $0xca // movslq %edx, %rcx + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x00e9890f; WORD $0x0000 // jns LBB19_68, $233(%rip) + WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x00da840f; WORD $0x0000 // je LBB19_68, $218(%rip) + +LBB19_57: + LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + +LBB19_60: + QUAD $0x00000000b045c748 // movq $0, $-80(%rbp) + LONG $0x6e0f4966; BYTE $0xcc // movq %r12, %xmm1 + QUAD $0xfffffc490d620f66 // punpckldq $-951(%rip), %xmm1 /* LCPI19_0(%rip) */ + QUAD $0xfffffc510d5c0f66 // subpd $-943(%rip), %xmm1 /* LCPI19_1(%rip) */ + LONG $0xc1280f66 // movapd %xmm1, %xmm0 + LONG $0xc1150f66 // unpckhpd %xmm1, %xmm0 + LONG $0xc1580ff2 // addsd %xmm1, %xmm0 + LONG $0x45110ff2; BYTE $0xc0 // movsd %xmm0, $-64(%rbp) + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0x34e8c148 // shrq $52, %rax + LONG $0x010f850f; WORD $0x0000 // jne LBB19_73, $271(%rip) + LONG $0x7e0f4866; BYTE $0xc1 // movq %xmm0, %rcx + WORD $0xd089 // movl %edx, %eax + WORD $0xe8c1; BYTE $0x1f // shrl $31, %eax + LONG $0x3fe0c148 // shlq $63, %rax + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xc0458948 // movq %rax, $-64(%rbp) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x018c840f; WORD $0x0000 // je LBB19_81, $396(%rip) + WORD $0xf685 // testl %esi, %esi + LONG $0x0184840f; WORD $0x0000 // je LBB19_81, $388(%rip) + LONG $0x6e0f4866; BYTE $0xc0 // movq %rax, %xmm0 + WORD $0x468d; BYTE $0xff // leal $-1(%rsi), %eax + WORD $0xf883; BYTE $0x24 // cmpl $36, %eax + LONG $0x0040870f; WORD $0x0000 // ja LBB19_66, $64(%rip) + WORD $0xfe83; BYTE $0x17 // cmpl $23, %esi + LONG $0x0095820f; WORD $0x0000 // jb LBB19_69, $149(%rip) + WORD $0x468d; BYTE $0xea // leal $-22(%rsi), %eax + LONG $0x790d8d48; WORD $0x00e1; BYTE $0x00 // leaq $57721(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0x04590ff2; BYTE $0xc1 // mulsd (%rcx,%rax,8), %xmm0 + LONG $0x45110ff2; BYTE $0xc0 // movsd %xmm0, $-64(%rbp) + LONG $0x000016b8; BYTE $0x00 // movl $22, %eax + LONG $0x000079e9; BYTE $0x00 // jmp LBB19_70, $121(%rip) + +LBB19_58: + LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) + WORD $0xce89 // movl %ecx, %esi + WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax + WORD $0xc084 // testb %al, %al + LONG $0xff1c850f; WORD $0xffff // jne LBB19_54, $-228(%rip) + LONG $0xfffdd3e9; BYTE $0xff // jmp LBB19_59, $-557(%rip) + +LBB19_66: + WORD $0xfe83; BYTE $0xea // cmpl $-22, %esi + LONG $0x008f820f; WORD $0x0000 // jb LBB19_73, $143(%rip) + WORD $0xdef7 // negl %esi + LONG $0x3a058d48; WORD $0x00e1; BYTE $0x00 // leaq $57658(%rip), %rax /* _P10_TAB(%rip) */ + LONG $0x045e0ff2; BYTE $0xf0 // divsd (%rax,%rsi,8), %xmm0 + LONG $0x45110ff2; BYTE $0xc0 // movsd %xmm0, $-64(%rbp) + LONG $0x0000d9e9; BYTE $0x00 // jmp LBB19_77, $217(%rip) + +LBB19_68: + LONG $0x6e0f4966; BYTE $0xc4 // movq %r12, %xmm0 + LONG $0xe1af0f4c // imulq %rcx, %r12 + LONG $0x1063894c // movq %r12, $16(%rbx) + QUAD $0xfffffb7605620f66 // punpckldq $-1162(%rip), %xmm0 /* LCPI19_0(%rip) */ + QUAD $0xfffffb7e055c0f66 // subpd $-1154(%rip), %xmm0 /* LCPI19_1(%rip) */ + LONG $0xc8280f66 // movapd %xmm0, %xmm1 + LONG $0xc8150f66 // unpckhpd %xmm0, %xmm1 + LONG $0xc8580ff2 // addsd %xmm0, %xmm1 + WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax + LONG $0x7e0f4866; BYTE $0xc9 // movq %xmm1, %rcx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + LONG $0x084b8948 // movq %rcx, $8(%rbx) + LONG $0x000109e9; BYTE $0x00 // jmp LBB19_85, $265(%rip) + +LBB19_69: + WORD $0xf089 // movl %esi, %eax + +LBB19_70: + QUAD $0xfffffb64052e0f66 // ucomisd $-1180(%rip), %xmm0 /* LCPI19_2(%rip) */ + LONG $0x002a870f; WORD $0x0000 // ja LBB19_73, $42(%rip) + QUAD $0xfffffb5e0d100ff2 // movsd $-1186(%rip), %xmm1 /* LCPI19_3(%rip) */ + LONG $0xc82e0f66 // ucomisd %xmm0, %xmm1 + LONG $0x0018870f; WORD $0x0000 // ja LBB19_73, $24(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0xc30d8d48; WORD $0x00e0; BYTE $0x00 // leaq $57539(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0x04590ff2; BYTE $0xc1 // mulsd (%rcx,%rax,8), %xmm0 + LONG $0x45110ff2; BYTE $0xc0 // movsd %xmm0, $-64(%rbp) + LONG $0x000062e9; BYTE $0x00 // jmp LBB19_77, $98(%rip) + +LBB19_73: + LONG $0xa05d894c // movq %r11, $-96(%rbp) + LONG $0xc855894c // movq %r10, $-56(%rbp) + LONG $0xc04d8d48 // leaq $-64(%rbp), %rcx + WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi + LONG $0xa8758948 // movq %rsi, $-88(%rbp) + LONG $0xffe38ce8; BYTE $0xff // callq _atof_eisel_lemire64, $-7284(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x004c840f; WORD $0x0000 // je LBB19_79, $76(%rip) + LONG $0x00bc7d83 // cmpl $0, $-68(%rbp) + LONG $0x006d840f; WORD $0x0000 // je LBB19_80, $109(%rip) + WORD $0xff49; BYTE $0xc4 // incq %r12 + LONG $0xb04d8d48 // leaq $-80(%rbp), %rcx + WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi + LONG $0xa8758b48 // movq $-88(%rbp), %rsi + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + LONG $0xffe364e8; BYTE $0xff // callq _atof_eisel_lemire64, $-7324(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x0024840f; WORD $0x0000 // je LBB19_79, $36(%rip) + LONG $0x4d100ff2; BYTE $0xb0 // movsd $-80(%rbp), %xmm1 + LONG $0x45100ff2; BYTE $0xc0 // movsd $-64(%rbp), %xmm0 + LONG $0xc82e0f66 // ucomisd %xmm0, %xmm1 + LONG $0x0010850f; WORD $0x0000 // jne LBB19_79, $16(%rip) + LONG $0x000a8a0f; WORD $0x0000 // jp LBB19_79, $10(%rip) + +LBB19_77: + LONG $0x7e0f4866; BYTE $0xc0 // movq %xmm0, %rax + LONG $0x00002fe9; BYTE $0x00 // jmp LBB19_81, $47(%rip) + +LBB19_79: + WORD $0x8b49; BYTE $0x06 // movq (%r14), %rax + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + LONG $0xa04d8b48 // movq $-96(%rbp), %rcx + LONG $0xffe8cce8; BYTE $0xff // callq _atof_native, $-5940(%rip) + LONG $0x45110ff2; BYTE $0xc0 // movsd %xmm0, $-64(%rbp) + LONG $0x7e0f4866; BYTE $0xc0 // movq %xmm0, %rax + LONG $0x000009e9; BYTE $0x00 // jmp LBB19_82, $9(%rip) + +LBB19_80: + LONG $0xc0458b48 // movq $-64(%rbp), %rax + +LBB19_81: + LONG $0x6e0f4866; BYTE $0xc0 // movq %rax, %xmm0 + +LBB19_82: + QUAD $0x000000000000b948; WORD $0x8000 // movabsq $-9223372036854775808, %rcx + WORD $0xff48; BYTE $0xc9 // decq %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + QUAD $0x000000000000b848; WORD $0x7ff0 // movabsq $9218868437227405312, %rax + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x0007850f; WORD $0x0000 // jne LBB19_84, $7(%rip) + LONG $0xf803c748; WORD $0xffff; BYTE $0xff // movq $-8, (%rbx) + +LBB19_84: + LONG $0x43110ff2; BYTE $0x08 // movsd %xmm0, $8(%rbx) + +LBB19_85: + WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) + LONG $0xfffd89e9; BYTE $0xff // jmp LBB19_52, $-631(%rip) + +LBB19_86: + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + +LBB19_87: + LONG $0xc6c68040 // addb $-58, %sil + LONG $0xf6fe8040 // cmpb $-10, %sil + LONG $0xfad7820f; WORD $0xffff // jb LBB19_5, $-1321(%rip) + WORD $0xf631 // xorl %esi, %esi + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0035830f; WORD $0x0000 // jae LBB19_93, $53(%rip) + WORD $0xf631 // xorl %esi, %esi + +LBB19_90: + LONG $0x0cb60f45; BYTE $0x07 // movzbl (%r15,%rax), %r9d + LONG $0xd0798d41 // leal $-48(%r9), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x0020870f; WORD $0x0000 // ja LBB19_93, $32(%rip) + LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi + WORD $0x3c8d; BYTE $0xb6 // leal (%rsi,%rsi,4), %edi + LONG $0x797c8d41; BYTE $0xd0 // leal $-48(%r9,%rdi,2), %edi + WORD $0x4c0f; BYTE $0xf7 // cmovll %edi, %esi + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 + LONG $0xffd0850f; WORD $0xffff // jne LBB19_90, $-48(%rip) + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + +LBB19_93: + LONG $0xf0af0f41 // imull %r8d, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0xfffd7de9; BYTE $0xff // jmp LBB19_60, $-643(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_vsigned: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) + WORD $0x570f; BYTE $0xc0 // xorps %xmm0, %xmm0 + LONG $0x0842110f // movups %xmm0, $8(%rdx) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + LONG $0x184a8948 // movq %rcx, $24(%rdx) + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x0046830f; WORD $0x0000 // jae LBB20_1, $70(%rip) + LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl + LONG $0x0018850f; WORD $0x0000 // jne LBB20_5, $24(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x0026830f; WORD $0x0000 // jae LBB20_1, $38(%rip) + LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + +LBB20_5: + WORD $0x798d; BYTE $0xc6 // leal $-58(%rcx), %edi + LONG $0xf5ff8040 // cmpb $-11, %dil + LONG $0x001a870f; WORD $0x0000 // ja LBB20_7, $26(%rip) + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfe02c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_1: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_7: + WORD $0xf980; BYTE $0x30 // cmpb $48, %cl + LONG $0x0032850f; WORD $0x0000 // jne LBB20_12, $50(%rip) + LONG $0x01508d4c // leaq $1(%rax), %r10 + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x0081830f; WORD $0x0000 // jae LBB20_11, $129(%rip) + LONG $0x3cb60f43; BYTE $0x11 // movzbl (%r9,%r10), %edi + WORD $0xc783; BYTE $0xd2 // addl $-46, %edi + WORD $0xff83; BYTE $0x37 // cmpl $55, %edi + LONG $0x0070870f; WORD $0x0000 // ja LBB20_11, $112(%rip) + QUAD $0x000000800001b948; WORD $0x0080 // movabsq $36028797027352577, %rcx + LONG $0xf9a30f48 // btq %rdi, %rcx + LONG $0x005c830f; WORD $0x0000 // jae LBB20_11, $92(%rip) + +LBB20_12: + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xd0470f4c // cmovaq %rax, %r10 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB20_13: + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x007d830f; WORD $0x0000 // jae LBB20_23, $125(%rip) + LONG $0x3cbe0f49; BYTE $0x01 // movsbq (%r9,%rax), %rdi + WORD $0x5f8d; BYTE $0xd0 // leal $-48(%rdi), %ebx + WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl + LONG $0x0033870f; WORD $0x0000 // ja LBB20_18, $51(%rip) + LONG $0x0ac96b48 // imulq $10, %rcx, %rcx + LONG $0x0013800f; WORD $0x0000 // jo LBB20_17, $19(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0xc783; BYTE $0xd0 // addl $-48, %edi + LONG $0xf8af0f49 // imulq %r8, %rdi + WORD $0x0148; BYTE $0xf9 // addq %rdi, %rcx + LONG $0xffc9810f; WORD $0xffff // jno LBB20_13, $-55(%rip) + +LBB20_17: + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfb02c748; WORD $0xffff; BYTE $0xff // movq $-5, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_11: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_18: + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x002d830f; WORD $0x0000 // jae LBB20_22, $45(%rip) + LONG $0x3cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %edi + WORD $0xff83; BYTE $0x2e // cmpl $46, %edi + LONG $0x0012840f; WORD $0x0000 // je LBB20_25, $18(%rip) + WORD $0xff83; BYTE $0x45 // cmpl $69, %edi + LONG $0x0009840f; WORD $0x0000 // je LBB20_25, $9(%rip) + WORD $0xff83; BYTE $0x65 // cmpl $101, %edi + LONG $0x000d850f; WORD $0x0000 // jne LBB20_22, $13(%rip) + +LBB20_25: + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfa02c748; WORD $0xffff; BYTE $0xff // movq $-6, (%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB20_22: + WORD $0x8949; BYTE $0xc2 // movq %rax, %r10 + +LBB20_23: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + LONG $0x104a8948 // movq %rcx, $16(%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + + // .p2align 4, 0x90 +_vunsigned: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0x08778b4c // movq $8(%rdi), %r14 + LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) + WORD $0x570f; BYTE $0xc0 // xorps %xmm0, %xmm0 + LONG $0x0842110f // movups %xmm0, $8(%rdx) + WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax + LONG $0x18428948 // movq %rax, $24(%rdx) + WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx + LONG $0x001c830f; WORD $0x0000 // jae LBB21_1, $28(%rip) + LONG $0x04b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %eax + WORD $0x2d3c // cmpb $45, %al + LONG $0x001e850f; WORD $0x0000 // jne LBB21_4, $30(%rip) + +LBB21_3: + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfa00c749; WORD $0xffff; BYTE $0xff // movq $-6, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_1: + WORD $0x894c; BYTE $0x36 // movq %r14, (%rsi) + LONG $0xff00c749; WORD $0xffff; BYTE $0xff // movq $-1, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_4: + WORD $0x508d; BYTE $0xc6 // leal $-58(%rax), %edx + WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl + LONG $0x000f870f; WORD $0x0000 // ja LBB21_6, $15(%rip) + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfe00c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_6: + WORD $0x303c // cmpb $48, %al + LONG $0x0026850f; WORD $0x0000 // jne LBB21_10, $38(%rip) + LONG $0x44b60f41; WORD $0x0109 // movzbl $1(%r9,%rcx), %eax + WORD $0xc083; BYTE $0xd2 // addl $-46, %eax + WORD $0xf883; BYTE $0x37 // cmpl $55, %eax + LONG $0x00c2870f; WORD $0x0000 // ja LBB21_9, $194(%rip) + QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx + LONG $0xc2a30f48 // btq %rax, %rdx + LONG $0x00ae830f; WORD $0x0000 // jae LBB21_9, $174(%rip) + +LBB21_10: + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0xd6470f4d // cmovaq %r14, %r10 + WORD $0xc031 // xorl %eax, %eax + LONG $0x000abb41; WORD $0x0000 // movl $10, %r11d + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB21_11: + WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx + LONG $0x007f830f; WORD $0x0000 // jae LBB21_22, $127(%rip) + LONG $0x1cbe0f41; BYTE $0x09 // movsbl (%r9,%rcx), %ebx + WORD $0x538d; BYTE $0xd0 // leal $-48(%rbx), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x0042870f; WORD $0x0000 // ja LBB21_17, $66(%rip) + WORD $0xf749; BYTE $0xe3 // mulq %r11 + LONG $0x0027800f; WORD $0x0000 // jo LBB21_16, $39(%rip) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0xc383; BYTE $0xd0 // addl $-48, %ebx + WORD $0xff31 // xorl %edi, %edi + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0xc7920f40 // setb %dil + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + WORD $0xf748; BYTE $0xda // negq %rdx + WORD $0x3148; BYTE $0xd7 // xorq %rdx, %rdi + LONG $0x0009850f; WORD $0x0000 // jne LBB21_16, $9(%rip) + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffb6890f; WORD $0xffff // jns LBB21_11, $-74(%rip) + +LBB21_16: + WORD $0xff48; BYTE $0xc9 // decq %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfb00c749; WORD $0xffff; BYTE $0xff // movq $-5, (%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_17: + WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx + LONG $0x0020830f; WORD $0x0000 // jae LBB21_21, $32(%rip) + LONG $0x14b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %edx + WORD $0xfa83; BYTE $0x2e // cmpl $46, %edx + LONG $0xff0c840f; WORD $0xffff // je LBB21_3, $-244(%rip) + WORD $0xfa83; BYTE $0x45 // cmpl $69, %edx + LONG $0xff03840f; WORD $0xffff // je LBB21_3, $-253(%rip) + WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx + LONG $0xfefa840f; WORD $0xffff // je LBB21_3, $-262(%rip) + +LBB21_21: + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + +LBB21_22: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + LONG $0x10408949 // movq %rax, $16(%r8) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB21_9: + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + BYTE $0x00 // .p2align 4, 0x00 + +LCPI22_0: + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000005 // .quad 5 + + // .p2align 4, 0x90 +_skip_array: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI22_0(%rip) */ + WORD $0x110f; BYTE $0x00 // movups %xmm0, (%rax) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0x000000e9; BYTE $0x00 // jmp _fsm_exec, $0(%rip) + + // .p2align 4, 0x90 +_fsm_exec: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x28ec8348 // subq $40, %rsp + LONG $0xb84d8948 // movq %rcx, $-72(%rbp) + LONG $0x003f8348 // cmpq $0, (%rdi) + LONG $0x03b1840f; WORD $0x0000 // je LBB23_2, $945(%rip) + WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0xd0758948 // movq %rsi, $-48(%rbp) + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + LONG $0xc8558948 // movq %rdx, $-56(%rbp) + LONG $0x000033e9; BYTE $0x00 // jmp LBB23_7, $51(%rip) + +LBB23_3: + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x000006b8; BYTE $0x00 // movl $6, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0x03a78f0f; WORD $0x0000 // jg LBB23_62, $935(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +LBB23_4: + LONG $0x01518d48 // leaq $1(%rcx), %rdx + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + +LBB23_5: + LONG $0xd7448949; BYTE $0x08 // movq %rax, $8(%r15,%rdx,8) + +LBB23_6: + LONG $0x003f8349 // cmpq $0, (%r15) + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + LONG $0x035c840f; WORD $0x0000 // je LBB23_54, $860(%rip) + +LBB23_7: + LONG $0xd06d8b4c // movq $-48(%rbp), %r13 + LONG $0x007d8b49 // movq (%r13), %rdi + LONG $0x08758b49 // movq $8(%r13), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffee30e8; BYTE $0xff // callq _advance_ns, $-4560(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x0348840f; WORD $0x0000 // je LBB23_2, $840(%rip) + LONG $0xfffe8349 // cmpq $-1, %r14 + LONG $0x0007850f; WORD $0x0000 // jne LBB23_10, $7(%rip) + LONG $0x24348b4d // movq (%r12), %r14 + WORD $0xff49; BYTE $0xce // decq %r14 + +LBB23_10: + WORD $0xbe0f; BYTE $0xf0 // movsbl %al, %esi + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + LONG $0xcf3c8b41 // movl (%r15,%rcx,8), %edi + WORD $0xcfff // decl %edi + WORD $0xff83; BYTE $0x05 // cmpl $5, %edi + LONG $0x0027870f; WORD $0x0000 // ja LBB23_14, $39(%rip) + LONG $0x7b1d8d48; WORD $0x0004; BYTE $0x00 // leaq $1147(%rip), %rbx /* LJTI23_0(%rip) */ + LONG $0xbb3c6348 // movslq (%rbx,%rdi,4), %rdi + WORD $0x0148; BYTE $0xdf // addq %rbx, %rdi + JMP DI + +LBB23_12: + WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi + LONG $0x01a8840f; WORD $0x0000 // je LBB23_35, $424(%rip) + WORD $0xfe83; BYTE $0x5d // cmpl $93, %esi + LONG $0x016c840f; WORD $0x0000 // je LBB23_32, $364(%rip) + LONG $0x000310e9; BYTE $0x00 // jmp LBB23_58, $784(%rip) + +LBB23_14: + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi + LONG $0x0099860f; WORD $0x0000 // jbe LBB23_26, $153(%rip) + LONG $0x0002d7e9; BYTE $0x00 // jmp LBB23_54, $727(%rip) + +LBB23_15: + WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi + LONG $0x0146840f; WORD $0x0000 // je LBB23_32, $326(%rip) + WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi + LONG $0x02e6850f; WORD $0x0000 // jne LBB23_58, $742(%rip) + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0xff3b8e0f; WORD $0xffff // jle LBB23_4, $-197(%rip) + LONG $0x0002dbe9; BYTE $0x00 // jmp LBB23_62, $731(%rip) + +LBB23_18: + WORD $0x223c // cmpb $34, %al + LONG $0x02c7850f; WORD $0x0000 // jne LBB23_58, $711(%rip) + QUAD $0x00000004cf04c749 // movq $4, (%r15,%rcx,8) + LONG $0x241c8b49 // movq (%r12), %rbx + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + +LBB23_20: + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xc0558d48 // leaq $-64(%rbp), %rdx + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + LONG $0xfff08fe8; BYTE $0xff // callq _advance_string, $-3953(%rip) + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0107890f; WORD $0x0000 // jns LBB23_33, $263(%rip) + LONG $0xc0458b48 // movq $-64(%rbp), %rax + LONG $0x000107e9; BYTE $0x00 // jmp LBB23_34, $263(%rip) + +LBB23_22: + WORD $0x3a3c // cmpb $58, %al + LONG $0x028b850f; WORD $0x0000 // jne LBB23_58, $651(%rip) + WORD $0xc031 // xorl %eax, %eax + LONG $0xfffef5e9; BYTE $0xff // jmp LBB23_5, $-267(%rip) + +LBB23_24: + WORD $0x5d3c // cmpb $93, %al + LONG $0x00d3840f; WORD $0x0000 // je LBB23_32, $211(%rip) + QUAD $0x00000001cf04c749 // movq $1, (%r15,%rcx,8) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi + LONG $0x0243870f; WORD $0x0000 // ja LBB23_54, $579(%rip) + +LBB23_26: + WORD $0xf189 // movl %esi, %ecx + LONG $0xbe158d48; WORD $0x0003; BYTE $0x00 // leaq $958(%rip), %rdx /* LJTI23_1(%rip) */ + LONG $0x8a0c6348 // movslq (%rdx,%rcx,4), %rcx + WORD $0x0148; BYTE $0xd1 // addq %rdx, %rcx + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + JMP CX + +LBB23_27: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx + LONG $0xff6b8d4c // leaq $-1(%rbx), %r13 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi + WORD $0x014c; BYTE $0xef // addq %r13, %rdi + LONG $0x08708b48 // movq $8(%rax), %rsi + WORD $0x294c; BYTE $0xee // subq %r13, %rsi + LONG $0x0006d1e8; BYTE $0x00 // callq _do_skip_number, $1745(%rip) + LONG $0xff488d48 // leaq $-1(%rax), %rcx + LONG $0xfec2c748; WORD $0xffff; BYTE $0xff // movq $-2, %rdx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xd1490f48 // cmovnsq %rcx, %rdx + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xe8480f4c // cmovsq %rax, %r13 + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0x24148949 // movq %rdx, (%r12) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfe6c890f; WORD $0xffff // jns LBB23_6, $-404(%rip) + LONG $0x0001dfe9; BYTE $0x00 // jmp LBB23_55, $479(%rip) + +LBB23_28: + WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi + LONG $0x003f840f; WORD $0x0000 // je LBB23_32, $63(%rip) + WORD $0xfe83; BYTE $0x22 // cmpl $34, %esi + LONG $0x01df850f; WORD $0x0000 // jne LBB23_58, $479(%rip) + QUAD $0x00000002cf04c749 // movq $2, (%r15,%rcx,8) + LONG $0x241c8b49 // movq (%r12), %rbx + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xc0558d48 // leaq $-64(%rbp), %rdx + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + LONG $0xffefa7e8; BYTE $0xff // callq _advance_string, $-4185(%rip) + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0052890f; WORD $0x0000 // jns LBB23_37, $82(%rip) + LONG $0xc0458b48 // movq $-64(%rbp), %rax + LONG $0x000052e9; BYTE $0x00 // jmp LBB23_38, $82(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +LBB23_32: + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xfe1d850f; WORD $0xffff // jne LBB23_7, $-483(%rip) + LONG $0x000183e9; BYTE $0x00 // jmp LBB23_55, $387(%rip) + +LBB23_33: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 + +LBB23_34: + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0x24048949 // movq %rax, (%r12) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfdf1890f; WORD $0xffff // jns LBB23_6, $-527(%rip) + LONG $0x000164e9; BYTE $0x00 // jmp LBB23_55, $356(%rip) + +LBB23_35: + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0x01758f0f; WORD $0x0000 // jg LBB23_62, $373(%rip) + WORD $0xc031 // xorl %eax, %eax + LONG $0xfffdc9e9; BYTE $0xff // jmp LBB23_4, $-567(%rip) + +LBB23_37: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 + +LBB23_38: + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0x24048949 // movq %rax, (%r12) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x0136880f; WORD $0x0000 // js LBB23_55, $310(%rip) + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x000004b8; BYTE $0x00 // movl $4, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0xfd9a8e0f; WORD $0xffff // jle LBB23_4, $-614(%rip) + LONG $0x00013ae9; BYTE $0x00 // jmp LBB23_62, $314(%rip) + +LBB23_40: + LONG $0x241c8b49 // movq (%r12), %rbx + LONG $0xd07d8b48 // movq $-48(%rbp), %rdi + LONG $0xfffe69e9; BYTE $0xff // jmp LBB23_20, $-407(%rip) + +LBB23_41: + LONG $0x242c8b4d // movq (%r12), %r13 + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi + WORD $0x014c; BYTE $0xef // addq %r13, %rdi + LONG $0x08708b48 // movq $8(%rax), %rsi + WORD $0x294c; BYTE $0xee // subq %r13, %rsi + LONG $0x0005aee8; BYTE $0x00 // callq _do_skip_number, $1454(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0126880f; WORD $0x0000 // js LBB23_66, $294(%rip) + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + LONG $0x24048949 // movq %rax, (%r12) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfd648f0f; WORD $0xffff // jg LBB23_6, $-668(%rip) + LONG $0x000127e9; BYTE $0x00 // jmp LBB23_68, $295(%rip) + +LBB23_43: + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x000005b8; BYTE $0x00 // movl $5, %eax + LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx + LONG $0xfd3b8e0f; WORD $0xffff // jle LBB23_4, $-709(%rip) + LONG $0x0000dbe9; BYTE $0x00 // jmp LBB23_62, $219(%rip) + +LBB23_44: + LONG $0x24048b49 // movq (%r12), %rax + LONG $0xd0758b48 // movq $-48(%rbp), %rsi + LONG $0x084e8b48 // movq $8(%rsi), %rcx + LONG $0xfc518d48 // leaq $-4(%rcx), %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0x00ce870f; WORD $0x0000 // ja LBB23_64, $206(%rip) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x148b; BYTE $0x01 // movl (%rcx,%rax), %edx + LONG $0x6c61fa81; WORD $0x6573 // cmpl $1702063201, %edx + LONG $0x0198850f; WORD $0x0000 // jne LBB23_78, $408(%rip) + LONG $0x04488d48 // leaq $4(%rax), %rcx + LONG $0x240c8949 // movq %rcx, (%r12) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfd098f0f; WORD $0xffff // jg LBB23_6, $-759(%rip) + LONG $0x00006ae9; BYTE $0x00 // jmp LBB23_52, $106(%rip) + +LBB23_47: + LONG $0x24048b49 // movq (%r12), %rax + LONG $0xd0758b48 // movq $-48(%rbp), %rsi + LONG $0x084e8b48 // movq $8(%rsi), %rcx + LONG $0xfd518d48 // leaq $-3(%rcx), %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0x008d870f; WORD $0x0000 // ja LBB23_64, $141(%rip) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + QUAD $0x6c6c756eff017c81 // cmpl $1819047278, $-1(%rcx,%rax) + LONG $0x002f840f; WORD $0x0000 // je LBB23_51, $47(%rip) + LONG $0x0000a5e9; BYTE $0x00 // jmp LBB23_69, $165(%rip) + +LBB23_49: + LONG $0x24048b49 // movq (%r12), %rax + LONG $0xd0758b48 // movq $-48(%rbp), %rsi + LONG $0x084e8b48 // movq $8(%rsi), %rcx + LONG $0xfd518d48 // leaq $-3(%rcx), %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0x005e870f; WORD $0x0000 // ja LBB23_64, $94(%rip) + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + QUAD $0x65757274ff017c81 // cmpl $1702195828, $-1(%rcx,%rax) + LONG $0x00ce850f; WORD $0x0000 // jne LBB23_73, $206(%rip) + +LBB23_51: + LONG $0x03488d48 // leaq $3(%rax), %rcx + LONG $0x240c8949 // movq %rcx, (%r12) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfc9a8f0f; WORD $0xffff // jg LBB23_6, $-870(%rip) + +LBB23_52: + WORD $0xff48; BYTE $0xc8 // decq %rax + +LBB23_54: + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0x000007e9; BYTE $0x00 // jmp LBB23_55, $7(%rip) + +LBB23_2: + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + +LBB23_55: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB23_58: + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB23_55, $-30(%rip) + +LBB23_62: + LONG $0xf9c5c749; WORD $0xffff; BYTE $0xff // movq $-7, %r13 + LONG $0xffffd6e9; BYTE $0xff // jmp LBB23_55, $-42(%rip) + +LBB23_64: + LONG $0x240c8949 // movq %rcx, (%r12) + LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + LONG $0xffffc6e9; BYTE $0xff // jmp LBB23_55, $-58(%rip) + +LBB23_66: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0xc5 // addq %rax, %r13 + LONG $0x242c894d // movq %r13, (%r12) + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xffffb0e9; BYTE $0xff // jmp LBB23_55, $-80(%rip) + +LBB23_68: + WORD $0xff49; BYTE $0xcd // decq %r13 + LONG $0xffffa8e9; BYTE $0xff // jmp LBB23_55, $-88(%rip) + +LBB23_69: + LONG $0xff508d48 // leaq $-1(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xff017c80; BYTE $0x6e // cmpb $110, $-1(%rcx,%rax) + LONG $0xff8e850f; WORD $0xffff // jne LBB23_55, $-114(%rip) + LONG $0x24048949 // movq %rax, (%r12) + LONG $0x75013c80 // cmpb $117, (%rcx,%rax) + LONG $0xff80850f; WORD $0xffff // jne LBB23_55, $-128(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) + LONG $0xff6d850f; WORD $0xffff // jne LBB23_55, $-147(%rip) + LONG $0x02508d48 // leaq $2(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x02017c80; BYTE $0x6c // cmpb $108, $2(%rcx,%rax) + LONG $0xff5a850f; WORD $0xffff // jne LBB23_55, $-166(%rip) + LONG $0x00004ee9; BYTE $0x00 // jmp LBB23_77, $78(%rip) + +LBB23_73: + LONG $0xff508d48 // leaq $-1(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + LONG $0xff017c80; BYTE $0x74 // cmpb $116, $-1(%rcx,%rax) + LONG $0xff3b850f; WORD $0xffff // jne LBB23_55, $-197(%rip) + LONG $0x24048949 // movq %rax, (%r12) + LONG $0x72013c80 // cmpb $114, (%rcx,%rax) + LONG $0xff2d850f; WORD $0xffff // jne LBB23_55, $-211(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x01017c80; BYTE $0x75 // cmpb $117, $1(%rcx,%rax) + LONG $0xff1a850f; WORD $0xffff // jne LBB23_55, $-230(%rip) + LONG $0x02508d48 // leaq $2(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x02017c80; BYTE $0x65 // cmpb $101, $2(%rcx,%rax) + LONG $0xff07850f; WORD $0xffff // jne LBB23_55, $-249(%rip) + +LBB23_77: + LONG $0x03c08348 // addq $3, %rax + LONG $0x24048949 // movq %rax, (%r12) + LONG $0xfffefae9; BYTE $0xff // jmp LBB23_55, $-262(%rip) + +LBB23_78: + LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + WORD $0xfa80; BYTE $0x61 // cmpb $97, %dl + LONG $0xfeea850f; WORD $0xffff // jne LBB23_55, $-278(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) + LONG $0xfed7850f; WORD $0xffff // jne LBB23_55, $-297(%rip) + LONG $0x02508d48 // leaq $2(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x02017c80; BYTE $0x73 // cmpb $115, $2(%rcx,%rax) + LONG $0xfec4850f; WORD $0xffff // jne LBB23_55, $-316(%rip) + LONG $0x03508d48 // leaq $3(%rax), %rdx + LONG $0x24148949 // movq %rdx, (%r12) + LONG $0x03017c80; BYTE $0x65 // cmpb $101, $3(%rcx,%rax) + LONG $0xfeb1850f; WORD $0xffff // jne LBB23_55, $-335(%rip) + LONG $0x04c08348 // addq $4, %rax + LONG $0x24048949 // movq %rax, (%r12) + LONG $0xfffea4e9; BYTE $0xff // jmp LBB23_55, $-348(%rip) + BYTE $0x90 // .p2align 2, 0x90 + + // .set L23_0_set_12, LBB23_12-LJTI23_0 + // .set L23_0_set_15, LBB23_15-LJTI23_0 + // .set L23_0_set_18, LBB23_18-LJTI23_0 + // .set L23_0_set_22, LBB23_22-LJTI23_0 + // .set L23_0_set_24, LBB23_24-LJTI23_0 + // .set L23_0_set_28, LBB23_28-LJTI23_0 +LJTI23_0: + LONG $0xfffffb8e // .long L23_0_set_12 + LONG $0xfffffbbd // .long L23_0_set_15 + LONG $0xfffffbe6 // .long L23_0_set_18 + LONG $0xfffffc22 // .long L23_0_set_22 + LONG $0xfffffc31 // .long L23_0_set_24 + LONG $0xfffffcc4 // .long L23_0_set_28 + + // .set L23_1_set_55, LBB23_55-LJTI23_1 + // .set L23_1_set_54, LBB23_54-LJTI23_1 + // .set L23_1_set_40, LBB23_40-LJTI23_1 + // .set L23_1_set_41, LBB23_41-LJTI23_1 + // .set L23_1_set_27, LBB23_27-LJTI23_1 + // .set L23_1_set_43, LBB23_43-LJTI23_1 + // .set L23_1_set_44, LBB23_44-LJTI23_1 + // .set L23_1_set_47, LBB23_47-LJTI23_1 + // .set L23_1_set_49, LBB23_49-LJTI23_1 + // .set L23_1_set_3, LBB23_3-LJTI23_1 +LJTI23_1: + LONG $0xfffffe8b // .long L23_1_set_55 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffd6f // .long L23_1_set_40 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffd7c // .long L23_1_set_41 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffc52 // .long L23_1_set_27 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffdb4 // .long L23_1_set_43 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffdce // .long L23_1_set_44 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe0f // .long L23_1_set_47 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe3e // .long L23_1_set_49 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffe7c // .long L23_1_set_54 + LONG $0xfffffaed // .long L23_1_set_3 + LONG $0x00000000 // .p2align 4, 0x00 + +LCPI24_0: + QUAD $0x0000000000000001 // .quad 1 + QUAD $0x0000000000000006 // .quad 6 + + // .p2align 4, 0x90 +_skip_object: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI24_0(%rip) */ + WORD $0x110f; BYTE $0x00 // movups %xmm0, (%rax) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0xfff890e9; BYTE $0xff // jmp _fsm_exec, $-1904(%rip) + + // .p2align 4, 0x90 +_skip_string: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + LONG $0x10ec8348 // subq $16, %rsp + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b48; BYTE $0x1e // movq (%rsi), %rbx + LONG $0xe8558d48 // leaq $-24(%rbp), %rdx + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xffea40e8; BYTE $0xff // callq _advance_string, $-5568(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0009890f; WORD $0x0000 // jns LBB25_1, $9(%rip) + LONG $0xe84d8b48 // movq $-24(%rbp), %rcx + LONG $0x000009e9; BYTE $0x00 // jmp LBB25_3, $9(%rip) + +LBB25_1: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + +LBB25_3: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +_skip_negative: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b48; BYTE $0x1e // movq (%rsi), %rbx + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0x08778b48 // movq $8(%rdi), %rsi + WORD $0x2948; BYTE $0xde // subq %rbx, %rsi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0x0000aee8; BYTE $0x00 // callq _do_skip_number, $174(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x000e880f; WORD $0x0000 // js LBB26_1, $14(%rip) + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + WORD $0xff48; BYTE $0xcb // decq %rbx + LONG $0x000010e9; BYTE $0x00 // jmp LBB26_3, $16(%rip) + +LBB26_1: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) + LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx + +LBB26_3: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI27_0: + QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' + +LCPI27_1: + QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' + +LCPI27_2: + QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0' + +LCPI27_3: + QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' + +LCPI27_4: + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + +LCPI27_5: + QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................' + +LCPI27_6: + QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE' + + // .p2align 4, 0x90 +_do_skip_number: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0255840f; WORD $0x0000 // je LBB27_1, $597(%rip) + WORD $0x3f80; BYTE $0x30 // cmpb $48, (%rdi) + LONG $0x0033850f; WORD $0x0000 // jne LBB27_6, $51(%rip) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x01fe8348 // cmpq $1, %rsi + LONG $0x02d8840f; WORD $0x0000 // je LBB27_55, $728(%rip) + LONG $0x014fb60f // movzbl $1(%rdi), %ecx + WORD $0xc183; BYTE $0xd2 // addl $-46, %ecx + WORD $0xf983; BYTE $0x37 // cmpl $55, %ecx + LONG $0x02c8870f; WORD $0x0000 // ja LBB27_55, $712(%rip) + QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx + LONG $0xcaa30f48 // btq %rcx, %rdx + LONG $0x02b4830f; WORD $0x0000 // jae LBB27_55, $692(%rip) + +LBB27_6: + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0x0313820f; WORD $0x0000 // jb LBB27_7, $787(%rip) + LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 + WORD $0xc031 // xorl %eax, %eax + QUAD $0xffff26056f0f4466; BYTE $0xff // movdqa $-218(%rip), %xmm8 /* LCPI27_0(%rip) */ + QUAD $0xffff2d0d6f0f4466; BYTE $0xff // movdqa $-211(%rip), %xmm9 /* LCPI27_1(%rip) */ + QUAD $0xffff34156f0f4466; BYTE $0xff // movdqa $-204(%rip), %xmm10 /* LCPI27_2(%rip) */ + QUAD $0xffffff3c1d6f0f66 // movdqa $-196(%rip), %xmm3 /* LCPI27_3(%rip) */ + QUAD $0xffffff44256f0f66 // movdqa $-188(%rip), %xmm4 /* LCPI27_4(%rip) */ + QUAD $0xffffff4c2d6f0f66 // movdqa $-180(%rip), %xmm5 /* LCPI27_5(%rip) */ + QUAD $0xffffff54356f0f66 // movdqa $-172(%rip), %xmm6 /* LCPI27_6(%rip) */ + LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB27_9: + LONG $0x3c6f0ff3; BYTE $0x07 // movdqu (%rdi,%rax), %xmm7 + LONG $0xc76f0f66 // movdqa %xmm7, %xmm0 + LONG $0x740f4166; BYTE $0xc0 // pcmpeqb %xmm8, %xmm0 + LONG $0xcf6f0f66 // movdqa %xmm7, %xmm1 + LONG $0x740f4166; BYTE $0xc9 // pcmpeqb %xmm9, %xmm1 + LONG $0xc8eb0f66 // por %xmm0, %xmm1 + LONG $0xc76f0f66 // movdqa %xmm7, %xmm0 + LONG $0xfc0f4166; BYTE $0xc2 // paddb %xmm10, %xmm0 + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + LONG $0xd3da0f66 // pminub %xmm3, %xmm2 + LONG $0xd0740f66 // pcmpeqb %xmm0, %xmm2 + LONG $0xc76f0f66 // movdqa %xmm7, %xmm0 + LONG $0xc4db0f66 // pand %xmm4, %xmm0 + LONG $0xc6740f66 // pcmpeqb %xmm6, %xmm0 + LONG $0xfd740f66 // pcmpeqb %xmm5, %xmm7 + LONG $0xd7d70f66 // pmovmskb %xmm7, %edx + LONG $0xd70f4466; BYTE $0xf8 // pmovmskb %xmm0, %r15d + LONG $0xd70f4466; BYTE $0xd9 // pmovmskb %xmm1, %r11d + LONG $0xf8eb0f66 // por %xmm0, %xmm7 + LONG $0xf9eb0f66 // por %xmm1, %xmm7 + LONG $0xfaeb0f66 // por %xmm2, %xmm7 + LONG $0xcfd70f66 // pmovmskb %xmm7, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx + LONG $0x0014840f; WORD $0x0000 // je LBB27_11, $20(%rip) + LONG $0xffffffbb; BYTE $0xff // movl $-1, %ebx + WORD $0xe3d3 // shll %cl, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xda21 // andl %ebx, %edx + WORD $0x2141; BYTE $0xdf // andl %ebx, %r15d + WORD $0x2144; BYTE $0xdb // andl %r11d, %ebx + WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d + +LBB27_11: + WORD $0x5a8d; BYTE $0xff // leal $-1(%rdx), %ebx + WORD $0xd321 // andl %edx, %ebx + LONG $0x020d850f; WORD $0x0000 // jne LBB27_12, $525(%rip) + LONG $0xff5f8d41 // leal $-1(%r15), %ebx + WORD $0x2144; BYTE $0xfb // andl %r15d, %ebx + LONG $0x0200850f; WORD $0x0000 // jne LBB27_12, $512(%rip) + LONG $0xff5b8d41 // leal $-1(%r11), %ebx + WORD $0x2144; BYTE $0xdb // andl %r11d, %ebx + LONG $0x01f3850f; WORD $0x0000 // jne LBB27_12, $499(%rip) + WORD $0xd285 // testl %edx, %edx + LONG $0x0013840f; WORD $0x0000 // je LBB27_19, $19(%rip) + WORD $0xbc0f; BYTE $0xd2 // bsfl %edx, %edx + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x01f4850f; WORD $0x0000 // jne LBB27_56, $500(%rip) + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + +LBB27_19: + WORD $0x8545; BYTE $0xff // testl %r15d, %r15d + LONG $0x0014840f; WORD $0x0000 // je LBB27_22, $20(%rip) + LONG $0xd7bc0f41 // bsfl %r15d, %edx + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x01d7850f; WORD $0x0000 // jne LBB27_56, $471(%rip) + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + +LBB27_22: + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x0014840f; WORD $0x0000 // je LBB27_25, $20(%rip) + LONG $0xd3bc0f41 // bsfl %r11d, %edx + LONG $0xfffa8349 // cmpq $-1, %r10 + LONG $0x01ba850f; WORD $0x0000 // jne LBB27_56, $442(%rip) + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + +LBB27_25: + WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx + LONG $0x00c0850f; WORD $0x0000 // jne LBB27_57, $192(%rip) + LONG $0xf0c68349 // addq $-16, %r14 + LONG $0x10c08348 // addq $16, %rax + LONG $0x0ffe8349 // cmpq $15, %r14 + LONG $0xfeeb870f; WORD $0xffff // ja LBB27_9, $-277(%rip) + LONG $0x070c8d48 // leaq (%rdi,%rax), %rcx + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x00a7840f; WORD $0x0000 // je LBB27_41, $167(%rip) + +LBB27_28: + LONG $0x311c8d4e // leaq (%rcx,%r14), %r11 + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + WORD $0x2948; BYTE $0xfe // subq %rdi, %rsi + WORD $0xc031 // xorl %eax, %eax + LONG $0xa43d8d4c; WORD $0x0001; BYTE $0x00 // leaq $420(%rip), %r15 /* LJTI27_0(%rip) */ + LONG $0x00002fe9; BYTE $0x00 // jmp LBB27_29, $47(%rip) + +LBB27_31: + WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx + LONG $0x009b850f; WORD $0x0000 // jne LBB27_40, $155(%rip) + +LBB27_32: + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x0150850f; WORD $0x0000 // jne LBB27_58, $336(%rip) + LONG $0x060c8d4c // leaq (%rsi,%rax), %r9 + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB27_39: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xc6 // cmpq %rax, %r14 + LONG $0x0060840f; WORD $0x0000 // je LBB27_41, $96(%rip) + +LBB27_29: + LONG $0x0114be0f // movsbl (%rcx,%rax), %edx + WORD $0x5a8d; BYTE $0xd0 // leal $-48(%rdx), %ebx + WORD $0xfb83; BYTE $0x0a // cmpl $10, %ebx + LONG $0xffe4820f; WORD $0xffff // jb LBB27_39, $-28(%rip) + WORD $0x5a8d; BYTE $0xd5 // leal $-43(%rdx), %ebx + WORD $0xfb83; BYTE $0x1a // cmpl $26, %ebx + LONG $0xffb5870f; WORD $0xffff // ja LBB27_31, $-75(%rip) + LONG $0x9f146349 // movslq (%r15,%rbx,4), %rdx + WORD $0x014c; BYTE $0xfa // addq %r15, %rdx + JMP DX + +LBB27_37: + LONG $0xfffa8349 // cmpq $-1, %r10 + LONG $0x0105850f; WORD $0x0000 // jne LBB27_58, $261(%rip) + LONG $0x06148d4c // leaq (%rsi,%rax), %r10 + LONG $0xffffbce9; BYTE $0xff // jmp LBB27_39, $-68(%rip) + +LBB27_35: + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x00f2850f; WORD $0x0000 // jne LBB27_58, $242(%rip) + LONG $0x06048d4c // leaq (%rsi,%rax), %r8 + LONG $0xffffa9e9; BYTE $0xff // jmp LBB27_39, $-87(%rip) + +LBB27_1: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0x00008fe9; BYTE $0x00 // jmp LBB27_55, $143(%rip) + +LBB27_57: + WORD $0x8941; BYTE $0xcb // movl %ecx, %r11d + WORD $0x0149; BYTE $0xfb // addq %rdi, %r11 + WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + +LBB27_41: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x001b850f; WORD $0x0000 // jne LBB27_42, $27(%rip) + LONG $0x000071e9; BYTE $0x00 // jmp LBB27_55, $113(%rip) + +LBB27_40: + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x005b840f; WORD $0x0000 // je LBB27_55, $91(%rip) + +LBB27_42: + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0052840f; WORD $0x0000 // je LBB27_55, $82(%rip) + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0049840f; WORD $0x0000 // je LBB27_55, $73(%rip) + WORD $0x2949; BYTE $0xfb // subq %rdi, %r11 + LONG $0xff438d49 // leaq $-1(%r11), %rax + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0033840f; WORD $0x0000 // je LBB27_47, $51(%rip) + WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 + LONG $0x002a840f; WORD $0x0000 // je LBB27_47, $42(%rip) + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x0021840f; WORD $0x0000 // je LBB27_47, $33(%rip) + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x00258e0f; WORD $0x0000 // jle LBB27_51, $37(%rip) + LONG $0xff428d49 // leaq $-1(%r10), %rax + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x0018840f; WORD $0x0000 // je LBB27_51, $24(%rip) + WORD $0xf749; BYTE $0xd2 // notq %r10 + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x000006e9; BYTE $0x00 // jmp LBB27_55, $6(%rip) + +LBB27_47: + WORD $0xf749; BYTE $0xdb // negq %r11 + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + +LBB27_55: + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB27_51: + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x094c; BYTE $0xc8 // orq %r9, %rax + WORD $0x990f; BYTE $0xc0 // setns %al + LONG $0x0014880f; WORD $0x0000 // js LBB27_54, $20(%rip) + WORD $0x394d; BYTE $0xc8 // cmpq %r9, %r8 + LONG $0x000b8c0f; WORD $0x0000 // jl LBB27_54, $11(%rip) + WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0xffffd6e9; BYTE $0xff // jmp LBB27_55, $-42(%rip) + +LBB27_54: + LONG $0xff498d49 // leaq $-1(%r9), %rcx + WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 + WORD $0xf749; BYTE $0xd1 // notq %r9 + LONG $0xcb450f4d // cmovneq %r11, %r9 + WORD $0xc084 // testb %al, %al + LONG $0xcb440f4d // cmoveq %r11, %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0xffffbae9; BYTE $0xff // jmp LBB27_55, $-70(%rip) + +LBB27_12: + WORD $0xbc0f; BYTE $0xcb // bsfl %ebx, %ecx + LONG $0x000010e9; BYTE $0x00 // jmp LBB27_13, $16(%rip) + +LBB27_58: + WORD $0x2948; BYTE $0xcf // subq %rcx, %rdi + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + LONG $0xffffa4e9; BYTE $0xff // jmp LBB27_55, $-92(%rip) + +LBB27_56: + WORD $0xd189 // movl %edx, %ecx + +LBB27_13: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x2948; BYTE $0xc8 // subq %rcx, %rax + LONG $0xffff97e9; BYTE $0xff // jmp LBB27_55, $-105(%rip) + +LBB27_7: + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 + LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 + LONG $0xfffe4ae9; BYTE $0xff // jmp LBB27_28, $-438(%rip) + BYTE $0x90 // .p2align 2, 0x90 + + // .set L27_0_set_37, LBB27_37-LJTI27_0 + // .set L27_0_set_40, LBB27_40-LJTI27_0 + // .set L27_0_set_35, LBB27_35-LJTI27_0 + // .set L27_0_set_32, LBB27_32-LJTI27_0 +LJTI27_0: + LONG $0xfffffeb5 // .long L27_0_set_37 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xfffffeb5 // .long L27_0_set_37 + LONG $0xfffffec8 // .long L27_0_set_35 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xffffff05 // .long L27_0_set_40 + LONG $0xfffffe6a // .long L27_0_set_32 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +_skip_positive: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b4c; BYTE $0x3e // movq (%rsi), %r15 + LONG $0xff5f8d49 // leaq $-1(%r15), %rbx + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax + LONG $0x08778b48 // movq $8(%rdi), %rsi + WORD $0x2948; BYTE $0xde // subq %rbx, %rsi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xfffbd7e8; BYTE $0xff // callq _do_skip_number, $-1065(%rip) + LONG $0xff508d48 // leaq $-1(%rax), %rdx + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0xfec6c748; WORD $0xffff; BYTE $0xff // movq $-2, %rsi + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xf2490f48 // cmovnsq %rdx, %rsi + LONG $0xcb490f48 // cmovnsq %rbx, %rcx + WORD $0x014c; BYTE $0xfe // addq %r15, %rsi + WORD $0x8949; BYTE $0x36 // movq %rsi, (%r14) + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_skip_number: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8b4c; BYTE $0x27 // movq (%rdi), %r12 + LONG $0x08778b48 // movq $8(%rdi), %rsi + WORD $0x8b4d; BYTE $0x3e // movq (%r14), %r15 + WORD $0xc031 // xorl %eax, %eax + LONG $0x3c3c8043; BYTE $0x2d // cmpb $45, (%r12,%r15) + LONG $0x3c1c8d4b // leaq (%r12,%r15), %rbx + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + LONG $0x003c840f; WORD $0x0000 // je LBB29_6, $60(%rip) + WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 + LONG $0x000d830f; WORD $0x0000 // jae LBB29_3, $13(%rip) + WORD $0xb60f; BYTE $0x03 // movzbl (%rbx), %eax + WORD $0xc604 // addb $-58, %al + WORD $0xf63c // cmpb $-10, %al + LONG $0x0038820f; WORD $0x0000 // jb LBB29_8, $56(%rip) + +LBB29_3: + WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi + LONG $0xfffb50e8; BYTE $0xff // callq _do_skip_number, $-1200(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0021880f; WORD $0x0000 // js LBB29_7, $33(%rip) + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + +LBB29_5: + WORD $0x294c; BYTE $0xe3 // subq %r12, %rbx + WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB29_6: + LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq $-1, %r15 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB29_5, $-30(%rip) + +LBB29_7: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + +LBB29_8: + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + LONG $0xffffd0e9; BYTE $0xff // jmp LBB29_5, $-48(%rip) + LONG $0x00000000 // .p2align 4, 0x00 + +LCPI30_0: + LONG $0x00000001 // .long 1 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + + // .p2align 4, 0x90 +_skip_one: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI30_0(%rip) */ + WORD $0x110f; BYTE $0x00 // movups %xmm0, (%rax) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0xfff250e9; BYTE $0xff // jmp _fsm_exec, $-3504(%rip) + + // .p2align 4, 0x00 +LCPI31_0: + LONG $0x00000001 // .long 1 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + + // .p2align 4, 0x90 +_validate_one: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI31_0(%rip) */ + WORD $0x110f; BYTE $0x00 // movups %xmm0, (%rax) + LONG $0x000020b9; BYTE $0x00 // movl $32, %ecx + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + BYTE $0x5d // popq %rbp + LONG $0xfff21be9; BYTE $0xff // jmp _fsm_exec, $-3557(%rip) + QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI32_0: + QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,' + +LCPI32_1: + QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' + +LCPI32_2: + QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]' + +LCPI32_3: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI32_4: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + +LCPI32_5: + QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{' + +LCPI32_6: + QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}' + +LCPI32_7: + QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[[' + + // .p2align 4, 0x90 +_skip_one_fast: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x68ec8348 // subq $104, %rsp + WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + WORD $0x8b48; BYTE $0x3f // movq (%rdi), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xea // movq %r13, %rdx + LONG $0xffe01ae8; BYTE $0xff // callq _advance_ns, $-8166(%rip) + LONG $0x00558b49 // movq (%r13), %rdx + LONG $0xff428d4c // leaq $-1(%rdx), %r8 + WORD $0xbe0f; BYTE $0xc8 // movsbl %al, %ecx + WORD $0xf983; BYTE $0x7b // cmpl $123, %ecx + LONG $0x0119870f; WORD $0x0000 // ja LBB32_19, $281(%rip) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0x80358d48; WORD $0x000b; BYTE $0x00 // leaq $2944(%rip), %rsi /* LJTI32_0(%rip) */ + LONG $0x8e0c6348 // movslq (%rsi,%rcx,4), %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + JMP CX + +LBB32_2: + WORD $0x8b49; BYTE $0x06 // movq (%r14), %rax + LONG $0x084e8b49 // movq $8(%r14), %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0x0ab0820f; WORD $0x0000 // jb LBB32_84, $2736(%rip) + WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi + WORD $0xf748; BYTE $0xde // negq %rsi + QUAD $0xffffff0a056f0f66 // movdqa $-246(%rip), %xmm0 /* LCPI32_0(%rip) */ + QUAD $0xffffff120d6f0f66 // movdqa $-238(%rip), %xmm1 /* LCPI32_1(%rip) */ + QUAD $0xffffff1a156f0f66 // movdqa $-230(%rip), %xmm2 /* LCPI32_2(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB32_4: + LONG $0x1c6f0ff3; BYTE $0x10 // movdqu (%rax,%rdx), %xmm3 + LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 + LONG $0xe0740f66 // pcmpeqb %xmm0, %xmm4 + LONG $0xd9db0f66 // pand %xmm1, %xmm3 + LONG $0xda740f66 // pcmpeqb %xmm2, %xmm3 + LONG $0xdceb0f66 // por %xmm4, %xmm3 + LONG $0xfbd70f66 // pmovmskb %xmm3, %edi + WORD $0xff85 // testl %edi, %edi + LONG $0x006b850f; WORD $0x0000 // jne LBB32_14, $107(%rip) + LONG $0x10c28348 // addq $16, %rdx + LONG $0x313c8d48 // leaq (%rcx,%rsi), %rdi + LONG $0xf0c78348 // addq $-16, %rdi + LONG $0xf0c68348 // addq $-16, %rsi + LONG $0x0fff8348 // cmpq $15, %rdi + LONG $0xffc1870f; WORD $0xffff // ja LBB32_4, $-63(%rip) + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x2948; BYTE $0xf2 // subq %rsi, %rdx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0034840f; WORD $0x0000 // je LBB32_13, $52(%rip) + +LBB32_7: + LONG $0x323c8d48 // leaq (%rdx,%rsi), %rdi + WORD $0xc931 // xorl %ecx, %ecx + +LBB32_8: + LONG $0x0a1cb60f // movzbl (%rdx,%rcx), %ebx + WORD $0xfb83; BYTE $0x2c // cmpl $44, %ebx + LONG $0x09f5840f; WORD $0x0000 // je LBB32_82, $2549(%rip) + WORD $0xfb83; BYTE $0x7d // cmpl $125, %ebx + LONG $0x09ec840f; WORD $0x0000 // je LBB32_82, $2540(%rip) + WORD $0xfb83; BYTE $0x5d // cmpl $93, %ebx + LONG $0x09e3840f; WORD $0x0000 // je LBB32_82, $2531(%rip) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi + LONG $0xffd5850f; WORD $0xffff // jne LBB32_8, $-43(%rip) + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + +LBB32_13: + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + LONG $0x0009d2e9; BYTE $0x00 // jmp LBB32_83, $2514(%rip) + +LBB32_14: + LONG $0xc7bc0f66 // bsfw %di, %ax + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax + +LBB32_15: + LONG $0x00458949 // movq %rax, (%r13) + +LBB32_16: + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + +LBB32_17: + LONG $0x68c48348 // addq $104, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB32_18: + LONG $0x03c28348 // addq $3, %rdx + LONG $0x08563b49 // cmpq $8(%r14), %rdx + LONG $0xffe3830f; WORD $0xffff // jae LBB32_17, $-29(%rip) + LONG $0x00099fe9; BYTE $0x00 // jmp LBB32_83, $2463(%rip) + +LBB32_19: + LONG $0x0045894d // movq %r8, (%r13) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xffffcee9; BYTE $0xff // jmp LBB32_17, $-50(%rip) + +LBB32_20: + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + LONG $0x084e8b4d // movq $8(%r14), %r9 + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x11148d4c // leaq (%rcx,%rdx), %r10 + WORD $0x2949; BYTE $0xd1 // subq %rdx, %r9 + LONG $0x20f98349 // cmpq $32, %r9 + LONG $0x098b820f; WORD $0x0000 // jb LBB32_28, $2443(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + QUAD $0xfffffe26056f0f66 // movdqa $-474(%rip), %xmm0 /* LCPI32_3(%rip) */ + QUAD $0xfffffe2e0d6f0f66 // movdqa $-466(%rip), %xmm1 /* LCPI32_4(%rip) */ + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + LONG $0x000029e9; BYTE $0x00 // jmp LBB32_22, $41(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB32_24: + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x00a5850f; WORD $0x0000 // jne LBB32_81, $165(%rip) + +LBB32_25: + LONG $0x20c48349 // addq $32, %r12 + LONG $0x310c8d4b // leaq (%r9,%r14), %rcx + LONG $0xe0c18348 // addq $-32, %rcx + LONG $0xe0c68349 // addq $-32, %r14 + LONG $0x1ff98348 // cmpq $31, %rcx + LONG $0x0935860f; WORD $0x0000 // jbe LBB32_26, $2357(%rip) + +LBB32_22: + LONG $0x6f0f43f3; WORD $0x2214 // movdqu (%r10,%r12), %xmm2 + LONG $0x6f0f43f3; WORD $0x225c; BYTE $0x10 // movdqu $16(%r10,%r12), %xmm3 + LONG $0xe26f0f66 // movdqa %xmm2, %xmm4 + LONG $0xe0740f66 // pcmpeqb %xmm0, %xmm4 + LONG $0xfcd70f66 // pmovmskb %xmm4, %edi + LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 + LONG $0xe0740f66 // pcmpeqb %xmm0, %xmm4 + LONG $0xccd70f66 // pmovmskb %xmm4, %ecx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + LONG $0xd9740f66 // pcmpeqb %xmm1, %xmm3 + LONG $0xfbd70f66 // pmovmskb %xmm3, %edi + LONG $0x10e7c148 // shlq $16, %rdi + WORD $0x0948; BYTE $0xf7 // orq %rsi, %rdi + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x094c; BYTE $0xde // orq %r11, %rsi + LONG $0xff8b840f; WORD $0xffff // je LBB32_24, $-117(%rip) + WORD $0x8944; BYTE $0xde // movl %r11d, %esi + WORD $0xd6f7 // notl %esi + WORD $0xfe21 // andl %edi, %esi + LONG $0x363c8d44 // leal (%rsi,%rsi), %r15d + WORD $0x0945; BYTE $0xdf // orl %r11d, %r15d + WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xfb21 // andl %edi, %ebx + LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0xf301 // addl %esi, %ebx + LONG $0xc3920f41 // setb %r11b + WORD $0xdb01 // addl %ebx, %ebx + LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx + WORD $0x2144; BYTE $0xfb // andl %r15d, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xd921 // andl %ebx, %ecx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0xff5b840f; WORD $0xffff // je LBB32_25, $-165(%rip) + +LBB32_81: + WORD $0xbc0f; BYTE $0xc1 // bsfl %ecx, %eax + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax + WORD $0x014c; BYTE $0xe0 // addq %r12, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xfffec8e9; BYTE $0xff // jmp LBB32_15, $-312(%rip) + +LBB32_29: + LONG $0xb845894c // movq %r8, $-72(%rbp) + LONG $0xc86d894c // movq %r13, $-56(%rbp) + LONG $0x084e8b49 // movq $8(%r14), %rcx + WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx + WORD $0x0349; BYTE $0x16 // addq (%r14), %rdx + QUAD $0x555555555555bb49; WORD $0x5555 // movabsq $6148914691236517205, %r11 + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + QUAD $0xfffd36156f0f4466; BYTE $0xff // movdqa $-714(%rip), %xmm10 /* LCPI32_4(%rip) */ + QUAD $0xfffffd1e0d6f0f66 // movdqa $-738(%rip), %xmm1 /* LCPI32_3(%rip) */ + LONG $0x760f4566; BYTE $0xc9 // pcmpeqd %xmm9, %xmm9 + QUAD $0xfffffd511d6f0f66 // movdqa $-687(%rip), %xmm3 /* LCPI32_7(%rip) */ + QUAD $0xfffffcf9256f0f66 // movdqa $-775(%rip), %xmm4 /* LCPI32_2(%rip) */ + QUAD $0x333333333333bf49; WORD $0x3333 // movabsq $3689348814741910323, %r15 + LONG $0xc0570f45 // xorps %xmm8, %xmm8 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x02748c0f; WORD $0x0000 // jl LBB32_38, $628(%rip) + +LBB32_32: + LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 + LONG $0x6a6f0ff3; BYTE $0x10 // movdqu $16(%rdx), %xmm5 + LONG $0x7a6f0ff3; BYTE $0x20 // movdqu $32(%rdx), %xmm7 + LONG $0x726f0ff3; BYTE $0x30 // movdqu $48(%rdx), %xmm6 + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xfad70f66 // pmovmskb %xmm2, %edi + LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx + LONG $0x30e3c148 // shlq $48, %rbx + LONG $0x20e1c148 // shlq $32, %rcx + WORD $0x0948; BYTE $0xd9 // orq %rbx, %rcx + LONG $0x10e6c148 // shlq $16, %rsi + WORD $0x0948; BYTE $0xce // orq %rcx, %rsi + WORD $0x0948; BYTE $0xf7 // orq %rsi, %rdi + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + WORD $0x094c; BYTE $0xd1 // orq %r10, %rcx + LONG $0x0012850f; WORD $0x0000 // jne LBB32_34, $18(%rip) + LONG $0xffc7c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdi + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xc04d8948 // movq %rcx, $-64(%rbp) + LONG $0x00003fe9; BYTE $0x00 // jmp LBB32_35, $63(%rip) + +LBB32_34: + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x2148; BYTE $0xf9 // andq %rdi, %rcx + LONG $0x09048d4c // leaq (%rcx,%rcx), %r8 + WORD $0x094d; BYTE $0xd0 // orq %r10, %r8 + WORD $0x894c; BYTE $0xc6 // movq %r8, %rsi + WORD $0xf748; BYTE $0xd6 // notq %rsi + QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx + WORD $0x2148; BYTE $0xdf // andq %rbx, %rdi + WORD $0x2148; BYTE $0xf7 // andq %rsi, %rdi + WORD $0xf631 // xorl %esi, %esi + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi + LONG $0xc6920f40 // setb %sil + LONG $0xc0758948 // movq %rsi, $-64(%rbp) + WORD $0x0148; BYTE $0xff // addq %rdi, %rdi + WORD $0x314c; BYTE $0xdf // xorq %r11, %rdi + WORD $0x214c; BYTE $0xc7 // andq %r8, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + +LBB32_35: + LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + LONG $0x20e6c148 // shlq $32, %rsi + WORD $0x0948; BYTE $0xce // orq %rcx, %rsi + LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xf1 // orq %rsi, %rcx + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + WORD $0x0948; BYTE $0xce // orq %rcx, %rsi + WORD $0x2148; BYTE $0xfe // andq %rdi, %rsi + LONG $0x6e0f4866; BYTE $0xd6 // movq %rsi, %xmm2 + LONG $0x3a0f4166; WORD $0xd144; BYTE $0x00 // pclmulqdq $0, %xmm9, %xmm2 + LONG $0x7e0f4966; BYTE $0xd0 // movq %xmm2, %r8 + WORD $0x314d; BYTE $0xe0 // xorq %r12, %r8 + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 + LONG $0xd70f4466; BYTE $0xd2 // pmovmskb %xmm2, %r10d + LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 + LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 + LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 + LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 + LONG $0xfad70f66 // pmovmskb %xmm2, %edi + LONG $0x30e7c148 // shlq $48, %rdi + LONG $0x20e6c148 // shlq $32, %rsi + WORD $0x0948; BYTE $0xfe // orq %rdi, %rsi + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xf1 // orq %rsi, %rcx + WORD $0x0949; BYTE $0xca // orq %rcx, %r10 + WORD $0x894d; BYTE $0xc4 // movq %r8, %r12 + WORD $0xf749; BYTE $0xd4 // notq %r12 + WORD $0x214d; BYTE $0xe2 // andq %r12, %r10 + LONG $0xc4740f66 // pcmpeqb %xmm4, %xmm0 + LONG $0xf8d70f66 // pmovmskb %xmm0, %edi + LONG $0xec740f66 // pcmpeqb %xmm4, %xmm5 + LONG $0xcdd70f66 // pmovmskb %xmm5, %ecx + LONG $0xfc740f66 // pcmpeqb %xmm4, %xmm7 + LONG $0xdfd70f66 // pmovmskb %xmm7, %ebx + LONG $0xf4740f66 // pcmpeqb %xmm4, %xmm6 + LONG $0xf6d70f66 // pmovmskb %xmm6, %esi + LONG $0x30e6c148 // shlq $48, %rsi + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x0948; BYTE $0xf3 // orq %rsi, %rbx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xd9 // orq %rbx, %rcx + WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi + QUAD $0x0f0f0f0f0f0fbb48; WORD $0x0f0f // movabsq $1085102592571150095, %rbx + WORD $0x214c; BYTE $0xe7 // andq %r12, %rdi + LONG $0x0065840f; WORD $0x0000 // je LBB32_30, $101(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB32_36: + LONG $0xff678d4c // leaq $-1(%rdi), %r12 + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + WORD $0xd148; BYTE $0xee // shrq %rsi + WORD $0x214c; BYTE $0xde // andq %r11, %rsi + WORD $0x2948; BYTE $0xf1 // subq %rsi, %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + WORD $0x214c; BYTE $0xfe // andq %r15, %rsi + LONG $0x02e9c148 // shrq $2, %rcx + WORD $0x214c; BYTE $0xf9 // andq %r15, %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0x04eec148 // shrq $4, %rsi + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + WORD $0x2148; BYTE $0xde // andq %rbx, %rsi + QUAD $0x010101010101b948; WORD $0x0101 // movabsq $72340172838076673, %rcx + LONG $0xf1af0f48 // imulq %rcx, %rsi + LONG $0x38eec148 // shrq $56, %rsi + WORD $0x014c; BYTE $0xee // addq %r13, %rsi + WORD $0x394c; BYTE $0xce // cmpq %r9, %rsi + LONG $0x05dd860f; WORD $0x0000 // jbe LBB32_80, $1501(%rip) + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0x214c; BYTE $0xe7 // andq %r12, %rdi + LONG $0xffa3850f; WORD $0xffff // jne LBB32_36, $-93(%rip) + +LBB32_30: + LONG $0x3ff8c149 // sarq $63, %r8 + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + WORD $0xd148; BYTE $0xe9 // shrq %rcx + WORD $0x214c; BYTE $0xd9 // andq %r11, %rcx + WORD $0x2949; BYTE $0xca // subq %rcx, %r10 + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + WORD $0x214c; BYTE $0xf9 // andq %r15, %rcx + LONG $0x02eac149 // shrq $2, %r10 + WORD $0x214d; BYTE $0xfa // andq %r15, %r10 + WORD $0x0149; BYTE $0xca // addq %rcx, %r10 + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + LONG $0x04e9c148 // shrq $4, %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx + QUAD $0x010101010101be48; WORD $0x0101 // movabsq $72340172838076673, %rsi + LONG $0xceaf0f48 // imulq %rsi, %rcx + LONG $0x38e9c148 // shrq $56, %rcx + WORD $0x0149; BYTE $0xcd // addq %rcx, %r13 + LONG $0x40c28348 // addq $64, %rdx + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + LONG $0xc0c18348 // addq $-64, %rcx + WORD $0x894d; BYTE $0xc4 // movq %r8, %r12 + LONG $0xc0558b4c // movq $-64(%rbp), %r10 + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0xfd8c8d0f; WORD $0xffff // jge LBB32_32, $-628(%rip) + +LBB32_38: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x05e08e0f; WORD $0x0000 // jle LBB32_85, $1504(%rip) + WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi + LONG $0x45110f44; BYTE $0xa0 // movups %xmm8, $-96(%rbp) + LONG $0x45110f44; BYTE $0x90 // movups %xmm8, $-112(%rbp) + LONG $0x45110f44; BYTE $0x80 // movups %xmm8, $-128(%rbp) + QUAD $0xffffff7085110f44 // movups %xmm8, $-144(%rbp) + WORD $0xd189 // movl %edx, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx + LONG $0x0036820f; WORD $0x0000 // jb LBB32_42, $54(%rip) + LONG $0xd07d8348; BYTE $0x20 // cmpq $32, $-48(%rbp) + LONG $0x0033820f; WORD $0x0000 // jb LBB32_43, $51(%rip) + LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 + LONG $0x526f0ff3; BYTE $0x10 // movdqu $16(%rdx), %xmm2 + QUAD $0xffffff70857f0ff3 // movdqu %xmm0, $-144(%rbp) + LONG $0x557f0ff3; BYTE $0x80 // movdqu %xmm2, $-128(%rbp) + LONG $0x20c28348 // addq $32, %rdx + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + LONG $0xe0518d4c // leaq $-32(%rcx), %r10 + LONG $0x90458d4c // leaq $-112(%rbp), %r8 + LONG $0x000013e9; BYTE $0x00 // jmp LBB32_44, $19(%rip) + +LBB32_42: + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + LONG $0xfffd17e9; BYTE $0xff // jmp LBB32_32, $-745(%rip) + +LBB32_43: + LONG $0x70858d4c; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %r8 + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + +LBB32_44: + LONG $0x10fa8349 // cmpq $16, %r10 + LONG $0x0049820f; WORD $0x0000 // jb LBB32_45, $73(%rip) + LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 + LONG $0x7f0f41f3; BYTE $0x00 // movdqu %xmm0, (%r8) + LONG $0x10c28348 // addq $16, %rdx + LONG $0x10c08349 // addq $16, %r8 + LONG $0xf0c28349 // addq $-16, %r10 + LONG $0x08fa8349 // cmpq $8, %r10 + LONG $0x0034830f; WORD $0x0000 // jae LBB32_52, $52(%rip) + +LBB32_46: + LONG $0x04fa8349 // cmpq $4, %r10 + LONG $0x0046820f; WORD $0x0000 // jb LBB32_47, $70(%rip) + +LBB32_53: + WORD $0x0a8b // movl (%rdx), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c28348 // addq $4, %rdx + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc28349 // addq $-4, %r10 + LONG $0x02fa8349 // cmpq $2, %r10 + LONG $0x0035830f; WORD $0x0000 // jae LBB32_48, $53(%rip) + LONG $0x000043e9; BYTE $0x00 // jmp LBB32_49, $67(%rip) + +LBB32_45: + LONG $0x08fa8349 // cmpq $8, %r10 + LONG $0xffcc820f; WORD $0xffff // jb LBB32_46, $-52(%rip) + +LBB32_52: + WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x08c28348 // addq $8, %rdx + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf8c28349 // addq $-8, %r10 + LONG $0x04fa8349 // cmpq $4, %r10 + LONG $0xffba830f; WORD $0xffff // jae LBB32_53, $-70(%rip) + +LBB32_47: + LONG $0x02fa8349 // cmpq $2, %r10 + LONG $0x0013820f; WORD $0x0000 // jb LBB32_49, $19(%rip) + +LBB32_48: + WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c28348 // addq $2, %rdx + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec28349 // addq $-2, %r10 + +LBB32_49: + WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi + LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %rdx + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + LONG $0xfc60840f; WORD $0xffff // je LBB32_32, $-928(%rip) + WORD $0xb60f; BYTE $0x0e // movzbl (%rsi), %ecx + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %rdx + LONG $0xfffc4ee9; BYTE $0xff // jmp LBB32_32, $-946(%rip) + +LBB32_54: + LONG $0x04c28348 // addq $4, %rdx + LONG $0x08563b49 // cmpq $8(%r14), %rdx + LONG $0xfaa5830f; WORD $0xffff // jae LBB32_17, $-1371(%rip) + LONG $0x000461e9; BYTE $0x00 // jmp LBB32_83, $1121(%rip) + +LBB32_55: + LONG $0xb845894c // movq %r8, $-72(%rbp) + LONG $0xc86d894c // movq %r13, $-56(%rbp) + LONG $0x084e8b49 // movq $8(%r14), %rcx + WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx + WORD $0x0349; BYTE $0x16 // addq (%r14), %rdx + QUAD $0x555555555555bb49; WORD $0x5555 // movabsq $6148914691236517205, %r11 + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + QUAD $0xfff907156f0f4466; BYTE $0xff // movdqa $-1785(%rip), %xmm10 /* LCPI32_4(%rip) */ + QUAD $0xfffff8ef0d6f0f66 // movdqa $-1809(%rip), %xmm1 /* LCPI32_3(%rip) */ + LONG $0x760f4566; BYTE $0xc9 // pcmpeqd %xmm9, %xmm9 + QUAD $0xfffff9021d6f0f66 // movdqa $-1790(%rip), %xmm3 /* LCPI32_5(%rip) */ + QUAD $0xfffff90a256f0f66 // movdqa $-1782(%rip), %xmm4 /* LCPI32_6(%rip) */ + QUAD $0x333333333333bf49; WORD $0x3333 // movabsq $3689348814741910323, %r15 + LONG $0xc0570f45 // xorps %xmm8, %xmm8 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x02758c0f; WORD $0x0000 // jl LBB32_64, $629(%rip) + +LBB32_58: + LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 + LONG $0x6a6f0ff3; BYTE $0x10 // movdqu $16(%rdx), %xmm5 + LONG $0x7a6f0ff3; BYTE $0x20 // movdqu $32(%rdx), %xmm7 + LONG $0x726f0ff3; BYTE $0x30 // movdqu $48(%rdx), %xmm6 + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xfad70f66 // pmovmskb %xmm2, %edi + LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx + LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + LONG $0x10e6c148 // shlq $16, %rsi + WORD $0x0948; BYTE $0xde // orq %rbx, %rsi + WORD $0x0948; BYTE $0xf7 // orq %rsi, %rdi + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + WORD $0x094c; BYTE $0xd1 // orq %r10, %rcx + LONG $0x0012850f; WORD $0x0000 // jne LBB32_60, $18(%rip) + LONG $0xffc7c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdi + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xc04d8948 // movq %rcx, $-64(%rbp) + LONG $0x00003fe9; BYTE $0x00 // jmp LBB32_61, $63(%rip) + +LBB32_60: + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x2148; BYTE $0xf9 // andq %rdi, %rcx + LONG $0x09048d4c // leaq (%rcx,%rcx), %r8 + WORD $0x094d; BYTE $0xd0 // orq %r10, %r8 + WORD $0x894c; BYTE $0xc6 // movq %r8, %rsi + WORD $0xf748; BYTE $0xd6 // notq %rsi + QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx + WORD $0x2148; BYTE $0xdf // andq %rbx, %rdi + WORD $0x2148; BYTE $0xf7 // andq %rsi, %rdi + WORD $0xf631 // xorl %esi, %esi + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi + LONG $0xc6920f40 // setb %sil + LONG $0xc0758948 // movq %rsi, $-64(%rbp) + WORD $0x0148; BYTE $0xff // addq %rdi, %rdi + WORD $0x314c; BYTE $0xdf // xorq %r11, %rdi + WORD $0x214c; BYTE $0xc7 // andq %r8, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + +LBB32_61: + LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + LONG $0x20e6c148 // shlq $32, %rsi + WORD $0x0948; BYTE $0xce // orq %rcx, %rsi + LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xf1 // orq %rsi, %rcx + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + WORD $0x0948; BYTE $0xce // orq %rcx, %rsi + WORD $0x2148; BYTE $0xfe // andq %rdi, %rsi + LONG $0x6e0f4866; BYTE $0xd6 // movq %rsi, %xmm2 + LONG $0x3a0f4166; WORD $0xd144; BYTE $0x00 // pclmulqdq $0, %xmm9, %xmm2 + LONG $0x7e0f4966; BYTE $0xd0 // movq %xmm2, %r8 + WORD $0x314d; BYTE $0xe0 // xorq %r12, %r8 + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 + LONG $0xd70f4466; BYTE $0xd2 // pmovmskb %xmm2, %r10d + LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 + LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 + LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 + LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 + LONG $0xfad70f66 // pmovmskb %xmm2, %edi + LONG $0x30e7c148 // shlq $48, %rdi + LONG $0x20e6c148 // shlq $32, %rsi + WORD $0x0948; BYTE $0xfe // orq %rdi, %rsi + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xf1 // orq %rsi, %rcx + WORD $0x0949; BYTE $0xca // orq %rcx, %r10 + WORD $0x894d; BYTE $0xc4 // movq %r8, %r12 + WORD $0xf749; BYTE $0xd4 // notq %r12 + WORD $0x214d; BYTE $0xe2 // andq %r12, %r10 + LONG $0xc4740f66 // pcmpeqb %xmm4, %xmm0 + LONG $0xf8d70f66 // pmovmskb %xmm0, %edi + LONG $0xec740f66 // pcmpeqb %xmm4, %xmm5 + LONG $0xcdd70f66 // pmovmskb %xmm5, %ecx + LONG $0xfc740f66 // pcmpeqb %xmm4, %xmm7 + LONG $0xdfd70f66 // pmovmskb %xmm7, %ebx + LONG $0xf4740f66 // pcmpeqb %xmm4, %xmm6 + LONG $0xf6d70f66 // pmovmskb %xmm6, %esi + LONG $0x30e6c148 // shlq $48, %rsi + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x0948; BYTE $0xf3 // orq %rsi, %rbx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xd9 // orq %rbx, %rcx + WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi + QUAD $0x0f0f0f0f0f0fbb48; WORD $0x0f0f // movabsq $1085102592571150095, %rbx + WORD $0x214c; BYTE $0xe7 // andq %r12, %rdi + LONG $0x0066840f; WORD $0x0000 // je LBB32_56, $102(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB32_62: + LONG $0xff678d4c // leaq $-1(%rdi), %r12 + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + WORD $0xd148; BYTE $0xee // shrq %rsi + WORD $0x214c; BYTE $0xde // andq %r11, %rsi + WORD $0x2948; BYTE $0xf1 // subq %rsi, %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + WORD $0x214c; BYTE $0xfe // andq %r15, %rsi + LONG $0x02e9c148 // shrq $2, %rcx + WORD $0x214c; BYTE $0xf9 // andq %r15, %rcx + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0x04eec148 // shrq $4, %rsi + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + WORD $0x2148; BYTE $0xde // andq %rbx, %rsi + QUAD $0x010101010101b948; WORD $0x0101 // movabsq $72340172838076673, %rcx + LONG $0xf1af0f48 // imulq %rcx, %rsi + LONG $0x38eec148 // shrq $56, %rsi + WORD $0x014c; BYTE $0xee // addq %r13, %rsi + WORD $0x394c; BYTE $0xce // cmpq %r9, %rsi + LONG $0x01ad860f; WORD $0x0000 // jbe LBB32_80, $429(%rip) + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0x214c; BYTE $0xe7 // andq %r12, %rdi + LONG $0xffa3850f; WORD $0xffff // jne LBB32_62, $-93(%rip) + +LBB32_56: + LONG $0x3ff8c149 // sarq $63, %r8 + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + WORD $0xd148; BYTE $0xe9 // shrq %rcx + WORD $0x214c; BYTE $0xd9 // andq %r11, %rcx + WORD $0x2949; BYTE $0xca // subq %rcx, %r10 + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + WORD $0x214c; BYTE $0xf9 // andq %r15, %rcx + LONG $0x02eac149 // shrq $2, %r10 + WORD $0x214d; BYTE $0xfa // andq %r15, %r10 + WORD $0x0149; BYTE $0xca // addq %rcx, %r10 + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + LONG $0x04e9c148 // shrq $4, %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx + QUAD $0x010101010101be48; WORD $0x0101 // movabsq $72340172838076673, %rsi + LONG $0xceaf0f48 // imulq %rsi, %rcx + LONG $0x38e9c148 // shrq $56, %rcx + WORD $0x0149; BYTE $0xcd // addq %rcx, %r13 + LONG $0x40c28348 // addq $64, %rdx + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + LONG $0xc0c18348 // addq $-64, %rcx + WORD $0x894d; BYTE $0xc4 // movq %r8, %r12 + LONG $0xc0558b4c // movq $-64(%rbp), %r10 + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0xfd8b8d0f; WORD $0xffff // jge LBB32_58, $-629(%rip) + +LBB32_64: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x01b08e0f; WORD $0x0000 // jle LBB32_85, $432(%rip) + WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi + LONG $0x45110f44; BYTE $0xa0 // movups %xmm8, $-96(%rbp) + LONG $0x45110f44; BYTE $0x90 // movups %xmm8, $-112(%rbp) + LONG $0x45110f44; BYTE $0x80 // movups %xmm8, $-128(%rbp) + QUAD $0xffffff7085110f44 // movups %xmm8, $-144(%rbp) + WORD $0xd189 // movl %edx, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx + LONG $0x0036820f; WORD $0x0000 // jb LBB32_68, $54(%rip) + LONG $0xd07d8348; BYTE $0x20 // cmpq $32, $-48(%rbp) + LONG $0x0033820f; WORD $0x0000 // jb LBB32_69, $51(%rip) + LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 + LONG $0x526f0ff3; BYTE $0x10 // movdqu $16(%rdx), %xmm2 + QUAD $0xffffff70857f0ff3 // movdqu %xmm0, $-144(%rbp) + LONG $0x557f0ff3; BYTE $0x80 // movdqu %xmm2, $-128(%rbp) + LONG $0x20c28348 // addq $32, %rdx + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + LONG $0xe0518d4c // leaq $-32(%rcx), %r10 + LONG $0x90458d4c // leaq $-112(%rbp), %r8 + LONG $0x000013e9; BYTE $0x00 // jmp LBB32_70, $19(%rip) + +LBB32_68: + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + LONG $0xfffd16e9; BYTE $0xff // jmp LBB32_58, $-746(%rip) + +LBB32_69: + LONG $0x70858d4c; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %r8 + LONG $0xd0558b4c // movq $-48(%rbp), %r10 + +LBB32_70: + LONG $0x10fa8349 // cmpq $16, %r10 + LONG $0x0049820f; WORD $0x0000 // jb LBB32_71, $73(%rip) + LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 + LONG $0x7f0f41f3; BYTE $0x00 // movdqu %xmm0, (%r8) + LONG $0x10c28348 // addq $16, %rdx + LONG $0x10c08349 // addq $16, %r8 + LONG $0xf0c28349 // addq $-16, %r10 + LONG $0x08fa8349 // cmpq $8, %r10 + LONG $0x0034830f; WORD $0x0000 // jae LBB32_78, $52(%rip) + +LBB32_72: + LONG $0x04fa8349 // cmpq $4, %r10 + LONG $0x0046820f; WORD $0x0000 // jb LBB32_73, $70(%rip) + +LBB32_79: + WORD $0x0a8b // movl (%rdx), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c28348 // addq $4, %rdx + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc28349 // addq $-4, %r10 + LONG $0x02fa8349 // cmpq $2, %r10 + LONG $0x0035830f; WORD $0x0000 // jae LBB32_74, $53(%rip) + LONG $0x000043e9; BYTE $0x00 // jmp LBB32_75, $67(%rip) + +LBB32_71: + LONG $0x08fa8349 // cmpq $8, %r10 + LONG $0xffcc820f; WORD $0xffff // jb LBB32_72, $-52(%rip) + +LBB32_78: + WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x08c28348 // addq $8, %rdx + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf8c28349 // addq $-8, %r10 + LONG $0x04fa8349 // cmpq $4, %r10 + LONG $0xffba830f; WORD $0xffff // jae LBB32_79, $-70(%rip) + +LBB32_73: + LONG $0x02fa8349 // cmpq $2, %r10 + LONG $0x0013820f; WORD $0x0000 // jb LBB32_75, $19(%rip) + +LBB32_74: + WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c28348 // addq $2, %rdx + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec28349 // addq $-2, %r10 + +LBB32_75: + WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi + LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %rdx + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + LONG $0xfc5f840f; WORD $0xffff // je LBB32_58, $-929(%rip) + WORD $0xb60f; BYTE $0x0e // movzbl (%rsi), %ecx + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %rdx + LONG $0xfffc4de9; BYTE $0xff // jmp LBB32_58, $-947(%rip) + +LBB32_80: + LONG $0x08468b49 // movq $8(%r14), %rax + LONG $0xcfbc0f48 // bsfq %rdi, %rcx + LONG $0xd04d2b48 // subq $-48(%rbp), %rcx + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) + LONG $0x084e8b49 // movq $8(%r14), %rcx + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0xc8420f48 // cmovbq %rax, %rcx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + LONG $0xc8470f48 // cmovaq %rax, %rcx + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xfff645e9; BYTE $0xff // jmp LBB32_17, $-2491(%rip) + +LBB32_82: + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + WORD $0x0148; BYTE $0xca // addq %rcx, %rdx + +LBB32_83: + LONG $0x00558949 // movq %rdx, (%r13) + LONG $0xfff633e9; BYTE $0xff // jmp LBB32_16, $-2509(%rip) + +LBB32_26: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0035850f; WORD $0x0000 // jne LBB32_86, $53(%rip) + WORD $0x014d; BYTE $0xe2 // addq %r12, %r10 + WORD $0x014d; BYTE $0xf1 // addq %r14, %r9 + +LBB32_28: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0068850f; WORD $0x0000 // jne LBB32_90, $104(%rip) + LONG $0xfff619e9; BYTE $0xff // jmp LBB32_17, $-2535(%rip) + +LBB32_84: + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xf5c0850f; WORD $0xffff // jne LBB32_7, $-2624(%rip) + LONG $0xfff5efe9; BYTE $0xff // jmp LBB32_13, $-2577(%rip) + +LBB32_85: + LONG $0x084e8b49 // movq $8(%r14), %rcx + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0xfff5f8e9; BYTE $0xff // jmp LBB32_17, $-2568(%rip) + +LBB32_86: + WORD $0x394d; BYTE $0xe1 // cmpq %r12, %r9 + LONG $0xf5ef840f; WORD $0xffff // je LBB32_17, $-2577(%rip) + WORD $0x014d; BYTE $0xe2 // addq %r12, %r10 + WORD $0xff49; BYTE $0xc2 // incq %r10 + WORD $0xf749; BYTE $0xd4 // notq %r12 + WORD $0x014d; BYTE $0xe1 // addq %r12, %r9 + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0024850f; WORD $0x0000 // jne LBB32_90, $36(%rip) + LONG $0xfff5d5e9; BYTE $0xff // jmp LBB32_17, $-2603(%rip) + +LBB32_88: + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + LONG $0xf5b6840f; WORD $0xffff // je LBB32_17, $-2634(%rip) + +LBB32_90: + LONG $0x02b60f41 // movzbl (%r10), %eax + WORD $0xf883; BYTE $0x5c // cmpl $92, %eax + LONG $0xffd4840f; WORD $0xffff // je LBB32_88, $-44(%rip) + WORD $0xf883; BYTE $0x22 // cmpl $34, %eax + LONG $0x0024840f; WORD $0x0000 // je LBB32_93, $36(%rip) + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + LONG $0xffcb850f; WORD $0xffff // jne LBB32_90, $-53(%rip) + LONG $0xfff57ce9; BYTE $0xff // jmp LBB32_17, $-2692(%rip) + +LBB32_93: + LONG $0xd0552b4c // subq $-48(%rbp), %r10 + WORD $0xff49; BYTE $0xc2 // incq %r10 + LONG $0x0055894d // movq %r10, (%r13) + LONG $0xfff569e9; BYTE $0xff // jmp LBB32_16, $-2711(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90 + + // .set L32_0_set_17, LBB32_17-LJTI32_0 + // .set L32_0_set_19, LBB32_19-LJTI32_0 + // .set L32_0_set_20, LBB32_20-LJTI32_0 + // .set L32_0_set_2, LBB32_2-LJTI32_0 + // .set L32_0_set_29, LBB32_29-LJTI32_0 + // .set L32_0_set_54, LBB32_54-LJTI32_0 + // .set L32_0_set_18, LBB32_18-LJTI32_0 + // .set L32_0_set_55, LBB32_55-LJTI32_0 +LJTI32_0: + LONG $0xfffff569 // .long L32_0_set_17 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff59b // .long L32_0_set_20 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff489 // .long L32_0_set_2 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff69a // .long L32_0_set_29 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffffab6 // .long L32_0_set_54 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff578 // .long L32_0_set_18 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff578 // .long L32_0_set_18 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffff58b // .long L32_0_set_19 + LONG $0xfffffac9 // .long L32_0_set_55 + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +_get_by_path: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x38ec8348 // subq $56, %rsp + WORD $0x8949; BYTE $0xf4 // movq %rsi, %r12 + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + LONG $0x08428b48 // movq $8(%rdx), %rax + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x037d840f; WORD $0x0000 // je LBB33_53, $893(%rip) + WORD $0x8b4c; BYTE $0x3a // movq (%rdx), %r15 + LONG $0x04e0c148 // shlq $4, %rax + WORD $0x014c; BYTE $0xf8 // addq %r15, %rax + LONG $0xa0458948 // movq %rax, $-96(%rbp) + +LBB33_2: + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffd23fe8; BYTE $0xff // callq _advance_ns, $-11713(%rip) + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x1749b60f // movzbl $23(%rcx), %ecx + WORD $0xe180; BYTE $0x1f // andb $31, %cl + WORD $0xf980; BYTE $0x18 // cmpb $24, %cl + LONG $0x02dc850f; WORD $0x0000 // jne LBB33_47, $732(%rip) + WORD $0x7b3c // cmpb $123, %al + LONG $0xc865894c // movq %r12, $-56(%rbp) + LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0x034d850f; WORD $0x0000 // jne LBB33_54, $845(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB33_4: + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffd201e8; BYTE $0xff // callq _advance_ns, $-11775(%rip) + WORD $0x223c // cmpb $34, %al + LONG $0x032a850f; WORD $0x0000 // jne LBB33_54, $810(%rip) + LONG $0x08478b49 // movq $8(%r15), %rax + WORD $0x8b4c; BYTE $0x28 // movq (%rax), %r13 + LONG $0x08788b4c // movq $8(%rax), %r15 + QUAD $0xffffffffb045c748 // movq $-1, $-80(%rbp) + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0x24248b4d // movq (%r12), %r12 + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0xb0558d48 // leaq $-80(%rbp), %rdx + LONG $0x001aa0e8; BYTE $0x00 // callq _advance_string_default, $6816(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0312880f; WORD $0x0000 // js LBB33_56, $786(%rip) + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0xb04d8b48 // movq $-80(%rbp), %rcx + LONG $0xfff98348 // cmpq $-1, %rcx + LONG $0x0009840f; WORD $0x0000 // je LBB33_8, $9(%rip) + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x01478e0f; WORD $0x0000 // jle LBB33_27, $327(%rip) + +LBB33_8: + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax + LONG $0x0047850f; WORD $0x0000 // jne LBB33_12, $71(%rip) + WORD $0x034d; BYTE $0x26 // addq (%r14), %r12 + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + WORD $0x9090 // .p2align 4, 0x90 + +LBB33_10: + LONG $0x10ff8349 // cmpq $16, %r15 + LONG $0x0086820f; WORD $0x0000 // jb LBB33_17, $134(%rip) + LONG $0x006f0ff3 // movdqu (%rax), %xmm0 + LONG $0x6f0f41f3; WORD $0x004d // movdqu (%r13), %xmm1 + LONG $0xc8740f66 // pcmpeqb %xmm0, %xmm1 + LONG $0xd1d70f66 // pmovmskb %xmm1, %edx + LONG $0x10c08348 // addq $16, %rax + LONG $0x10c58349 // addq $16, %r13 + LONG $0xf0c78349 // addq $-16, %r15 + LONG $0x10c18348 // addq $16, %rcx + LONG $0x10c48349 // addq $16, %r12 + LONG $0xfffffa81; WORD $0x0000 // cmpl $65535, %edx + LONG $0xffc4840f; WORD $0xffff // je LBB33_10, $-60(%rip) + +LBB33_12: + WORD $0xdb31 // xorl %ebx, %ebx + +LBB33_13: + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + +LBB33_14: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffd13be8; BYTE $0xff // callq _advance_ns, $-11973(%rip) + WORD $0x3a3c // cmpb $58, %al + LONG $0x0264850f; WORD $0x0000 // jne LBB33_54, $612(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x023a850f; WORD $0x0000 // jne LBB33_52, $570(%rip) + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0xfff0dfe8; BYTE $0xff // callq _skip_one_fast, $-3873(%rip) + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffd110e8; BYTE $0xff // callq _advance_ns, $-12016(%rip) + WORD $0x2c3c // cmpb $44, %al + LONG $0xfef8840f; WORD $0xffff // je LBB33_4, $-264(%rip) + LONG $0x000234e9; BYTE $0x00 // jmp LBB33_54, $564(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_17: + LONG $0xffe48141; WORD $0x000f; BYTE $0x00 // andl $4095, %r12d + LONG $0xf0fc8141; WORD $0x000f; BYTE $0x00 // cmpl $4080, %r12d + LONG $0x0048870f; WORD $0x0000 // ja LBB33_21, $72(%rip) + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0ff1f981; WORD $0x0000 // cmpl $4081, %ecx + LONG $0x0036830f; WORD $0x0000 // jae LBB33_21, $54(%rip) + LONG $0x006f0ff3 // movdqu (%rax), %xmm0 + LONG $0x6f0f41f3; WORD $0x004d // movdqu (%r13), %xmm1 + LONG $0xc8740f66 // pcmpeqb %xmm0, %xmm1 + LONG $0xc1d70f66 // pmovmskb %xmm1, %eax + LONG $0xfff88366 // cmpw $-1, %ax + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0x004a840f; WORD $0x0000 // je LBB33_25, $74(%rip) + WORD $0xd0f7 // notl %eax + LONG $0xc0bc0f66 // bsfw %ax, %ax + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x3949; BYTE $0xc7 // cmpq %rax, %r15 + WORD $0x960f; BYTE $0xc3 // setbe %bl + LONG $0xffff56e9; BYTE $0xff // jmp LBB33_14, $-170(%rip) + +LBB33_21: + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0xff44840f; WORD $0xffff // je LBB33_14, $-188(%rip) + WORD $0xc931 // xorl %ecx, %ecx + + // .p2align 4, 0x90 +LBB33_23: + LONG $0x0814b60f // movzbl (%rax,%rcx), %edx + LONG $0x0d543a41; BYTE $0x00 // cmpb (%r13,%rcx), %dl + LONG $0x011d850f; WORD $0x0000 // jne LBB33_26, $285(%rip) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0xffe5850f; WORD $0xffff // jne LBB33_23, $-27(%rip) + LONG $0xffff22e9; BYTE $0xff // jmp LBB33_14, $-222(%rip) + +LBB33_25: + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0xffff18e9; BYTE $0xff // jmp LBB33_14, $-232(%rip) + +LBB33_27: + QUAD $0x00000000b845c748 // movq $0, $-72(%rbp) + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + WORD $0x0149; BYTE $0xcc // addq %rcx, %r12 + LONG $0xc065894c // movq %r12, $-64(%rbp) + LONG $0x01348d48 // leaq (%rcx,%rax), %rsi + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x2f3c8d4b // leaq (%r15,%r13), %rdi + WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 + LONG $0x00c9830f; WORD $0x0000 // jae LBB33_44, $201(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x00c08e0f; WORD $0x0000 // jle LBB33_44, $192(%rip) + LONG $0xb8558d48 // leaq $-72(%rbp), %rdx + LONG $0xa8758948 // movq %rsi, $-88(%rbp) + +LBB33_30: + LONG $0x04b60f41; BYTE $0x24 // movzbl (%r12), %eax + WORD $0x5c3c // cmpb $92, %al + LONG $0x0069850f; WORD $0x0000 // jne LBB33_37, $105(%rip) + WORD $0x8948; BYTE $0xfb // movq %rdi, %rbx + LONG $0xc07d8d48 // leaq $-64(%rbp), %rdi + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0x001c93e8; BYTE $0x00 // callq _unescape, $7315(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0168880f; WORD $0x0000 // js LBB33_57, $360(%rip) + LONG $0x280c8d48 // leaq (%rax,%rbp), %rcx + LONG $0xb8c18348 // addq $-72, %rcx + WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi + WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 + LONG $0xc8658b4c // movq $-56(%rbp), %r12 + LONG $0x0052830f; WORD $0x0000 // jae LBB33_39, $82(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0x0049840f; WORD $0x0000 // je LBB33_40, $73(%rip) + +LBB33_34: + LONG $0x5db60f41; BYTE $0x00 // movzbl (%r13), %ebx + WORD $0x183a // cmpb (%rax), %bl + LONG $0x003c850f; WORD $0x0000 // jne LBB33_40, $60(%rip) + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3949; BYTE $0xfd // cmpq %rdi, %r13 + LONG $0x002d830f; WORD $0x0000 // jae LBB33_40, $45(%rip) + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0xffdb820f; WORD $0xffff // jb LBB33_34, $-37(%rip) + LONG $0x00001fe9; BYTE $0x00 // jmp LBB33_40, $31(%rip) + +LBB33_37: + LONG $0x00453a41 // cmpb (%r13), %al + LONG $0xfe5b850f; WORD $0xffff // jne LBB33_12, $-421(%rip) + WORD $0xff49; BYTE $0xc4 // incq %r12 + LONG $0xc065894c // movq %r12, $-64(%rbp) + WORD $0xff49; BYTE $0xc5 // incq %r13 + LONG $0x000017e9; BYTE $0x00 // jmp LBB33_42, $23(%rip) + +LBB33_39: + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + +LBB33_40: + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x002d850f; WORD $0x0000 // jne LBB33_26, $45(%rip) + LONG $0xc0658b4c // movq $-64(%rbp), %r12 + LONG $0xa8758b48 // movq $-88(%rbp), %rsi + +LBB33_42: + WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 + LONG $0x0009830f; WORD $0x0000 // jae LBB33_44, $9(%rip) + WORD $0x3949; BYTE $0xfd // cmpq %rdi, %r13 + LONG $0xff48820f; WORD $0xffff // jb LBB33_30, $-184(%rip) + +LBB33_44: + WORD $0x3149; BYTE $0xf4 // xorq %rsi, %r12 + WORD $0x3149; BYTE $0xfd // xorq %rdi, %r13 + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x094d; BYTE $0xe5 // orq %r12, %r13 + WORD $0x940f; BYTE $0xc3 // sete %bl + LONG $0xfffe12e9; BYTE $0xff // jmp LBB33_13, $-494(%rip) + +LBB33_26: + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xfffe0fe9; BYTE $0xff // jmp LBB33_14, $-497(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_47: + WORD $0xf980; BYTE $0x02 // cmpb $2, %cl + LONG $0x0078850f; WORD $0x0000 // jne LBB33_54, $120(%rip) + WORD $0x5b3c // cmpb $91, %al + LONG $0x0070850f; WORD $0x0000 // jne LBB33_54, $112(%rip) + LONG $0x08478b49 // movq $8(%r15), %rax + WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_50: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00348e0f; WORD $0x0000 // jle LBB33_52, $52(%rip) + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0xffeed9e8; BYTE $0xff // callq _skip_one_fast, $-4391(%rip) + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffcf0ae8; BYTE $0xff // callq _advance_ns, $-12534(%rip) + WORD $0x2c3c // cmpb $44, %al + LONG $0xffd2840f; WORD $0xffff // je LBB33_50, $-46(%rip) + LONG $0x00002ee9; BYTE $0x00 // jmp LBB33_54, $46(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB33_52: + LONG $0x10c78349 // addq $16, %r15 + LONG $0xa0458b48 // movq $-96(%rbp), %rax + WORD $0x3949; BYTE $0xc7 // cmpq %rax, %r15 + LONG $0xfc91850f; WORD $0xffff // jne LBB33_2, $-879(%rip) + +LBB33_53: + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0xffee94e8; BYTE $0xff // callq _skip_one_fast, $-4460(%rip) + LONG $0x00000be9; BYTE $0x00 // jmp LBB33_55, $11(%rip) + +LBB33_54: + LONG $0x240cff49 // decq (%r12) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + +LBB33_55: + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB33_56: + LONG $0x08468b49 // movq $8(%r14), %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffffdee9; BYTE $0xff // jmp LBB33_55, $-34(%rip) + +LBB33_57: + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x2b49; BYTE $0x0e // subq (%r14), %rcx + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0xffffcbe9; BYTE $0xff // jmp LBB33_55, $-53(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_validate_utf8: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x1a048d4f // leaq (%r10,%r11), %r8 + LONG $0xfdc08349 // addq $-3, %r8 + LONG $0x00000de9; BYTE $0x00 // jmp LBB34_1, $13(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB34_19: + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + +LBB34_1: + WORD $0x394c; BYTE $0xc1 // cmpq %r8, %rcx + LONG $0x00e1830f; WORD $0x0000 // jae LBB34_2, $225(%rip) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) + LONG $0xffe6890f; WORD $0xffff // jns LBB34_19, $-26(%rip) + WORD $0x018b // movl (%rcx), %eax + WORD $0xc789 // movl %eax, %edi + LONG $0xc0f0e781; WORD $0x00c0 // andl $12632304, %edi + LONG $0x80e0ff81; WORD $0x0080 // cmpl $8421600, %edi + LONG $0x0030850f; WORD $0x0000 // jne LBB34_10, $48(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi + LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi + LONG $0x001c840f; WORD $0x0000 // je LBB34_10, $28(%rip) + LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx + WORD $0xff85 // testl %edi, %edi + LONG $0xffaf850f; WORD $0xffff // jne LBB34_19, $-81(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB34_10: + WORD $0xc789 // movl %eax, %edi + LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi + LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi + LONG $0x0010850f; WORD $0x0000 // jne LBB34_12, $16(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx + WORD $0xe783; BYTE $0x1e // andl $30, %edi + LONG $0xff7c850f; WORD $0xffff // jne LBB34_19, $-132(%rip) + +LBB34_12: + WORD $0xc789 // movl %eax, %edi + LONG $0xc0f8e781; WORD $0xc0c0 // andl $-1061109512, %edi + LONG $0x80f0ff81; WORD $0x8080 // cmpl $-2139062032, %edi + LONG $0x0026850f; WORD $0x0000 // jne LBB34_16, $38(%rip) + WORD $0xc789 // movl %eax, %edi + LONG $0x3007e781; WORD $0x0000 // andl $12295, %edi + LONG $0x0018840f; WORD $0x0000 // je LBB34_16, $24(%rip) + LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx + WORD $0x04a8 // testb $4, %al + LONG $0xff4d840f; WORD $0xffff // je LBB34_19, $-179(%rip) + LONG $0x00300325; BYTE $0x00 // andl $12291, %eax + LONG $0xff42840f; WORD $0xffff // je LBB34_19, $-190(%rip) + +LBB34_16: + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x294c; BYTE $0xd7 // subq %r10, %rdi + WORD $0x8b48; BYTE $0x1a // movq (%rdx), %rbx + LONG $0x00fb8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rbx + LONG $0x0187830f; WORD $0x0000 // jae LBB34_17, $391(%rip) + WORD $0x6348; BYTE $0xc7 // movslq %edi, %rax + LONG $0x017b8d48 // leaq $1(%rbx), %rdi + WORD $0x8948; BYTE $0x3a // movq %rdi, (%rdx) + LONG $0xda448948; BYTE $0x08 // movq %rax, $8(%rdx,%rbx,8) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0xffff13e9; BYTE $0xff // jmp LBB34_19, $-237(%rip) + +LBB34_2: + WORD $0x014d; BYTE $0xd3 // addq %r10, %r11 + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x013e830f; WORD $0x0000 // jae LBB34_36, $318(%rip) + LONG $0xdc458d4c // leaq $-36(%rbp), %r8 + LONG $0xda4d8d4c // leaq $-38(%rbp), %r9 + LONG $0x000016e9; BYTE $0x00 // jmp LBB34_4, $22(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB34_5: + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x011b830f; WORD $0x0000 // jae LBB34_36, $283(%rip) + +LBB34_4: + WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) + LONG $0xffeb890f; WORD $0xffff // jns LBB34_5, $-21(%rip) + LONG $0x00dc45c6 // movb $0, $-36(%rbp) + LONG $0x00da45c6 // movb $0, $-38(%rbp) + WORD $0x894c; BYTE $0xdb // movq %r11, %rbx + WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0035820f; WORD $0x0000 // jb LBB34_21, $53(%rip) + LONG $0x21b60f44 // movzbl (%rcx), %r12d + LONG $0x71b60f44; BYTE $0x01 // movzbl $1(%rcx), %r14d + LONG $0xdc658844 // movb %r12b, $-36(%rbp) + LONG $0x02798d4c // leaq $2(%rcx), %r15 + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x894c; BYTE $0xcf // movq %r9, %rdi + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0029840f; WORD $0x0000 // je LBB34_24, $41(%rip) + +LBB34_25: + LONG $0x07b60f41 // movzbl (%r15), %eax + WORD $0x0788 // movb %al, (%rdi) + LONG $0x65b60f44; BYTE $0xdc // movzbl $-36(%rbp), %r12d + LONG $0xda7db60f // movzbl $-38(%rbp), %edi + LONG $0x000017e9; BYTE $0x00 // jmp LBB34_26, $23(%rip) + +LBB34_21: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xffd7850f; WORD $0xffff // jne LBB34_25, $-41(%rip) + +LBB34_24: + WORD $0xff31 // xorl %edi, %edi + +LBB34_26: + LONG $0xc7b60f40 // movzbl %dil, %eax + WORD $0xe0c1; BYTE $0x10 // shll $16, %eax + LONG $0xdeb60f41 // movzbl %r14b, %ebx + WORD $0xe3c1; BYTE $0x08 // shll $8, %ebx + WORD $0xc309 // orl %eax, %ebx + LONG $0xfcb60f41 // movzbl %r12b, %edi + WORD $0xdf09 // orl %ebx, %edi + WORD $0xf889 // movl %edi, %eax + LONG $0xc0c0f025; BYTE $0x00 // andl $12632304, %eax + LONG $0x8080e03d; BYTE $0x00 // cmpl $8421600, %eax + LONG $0x001f850f; WORD $0x0000 // jne LBB34_29, $31(%rip) + WORD $0xf889 // movl %edi, %eax + LONG $0x00200f25; BYTE $0x00 // andl $8207, %eax + LONG $0x00200d3d; BYTE $0x00 // cmpl $8205, %eax + LONG $0x000d840f; WORD $0x0000 // je LBB34_29, $13(%rip) + LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx + WORD $0xc085 // testl %eax, %eax + LONG $0x0021850f; WORD $0x0000 // jne LBB34_34, $33(%rip) + + // .p2align 4, 0x90 +LBB34_29: + LONG $0x1ec4f641 // testb $30, %r12b + LONG $0x0028840f; WORD $0x0000 // je LBB34_31, $40(%rip) + LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi + LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx + LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi + LONG $0x0011850f; WORD $0x0000 // jne LBB34_31, $17(%rip) + +LBB34_34: + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0xff1f820f; WORD $0xffff // jb LBB34_4, $-225(%rip) + LONG $0x000035e9; BYTE $0x00 // jmp LBB34_36, $53(%rip) + +LBB34_31: + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + WORD $0x294c; BYTE $0xd0 // subq %r10, %rax + WORD $0x8b48; BYTE $0x3a // movq (%rdx), %rdi + LONG $0x00ff8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rdi + LONG $0x0034830f; WORD $0x0000 // jae LBB34_32, $52(%rip) + WORD $0x9848 // cltq + LONG $0x015f8d48 // leaq $1(%rdi), %rbx + WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) + LONG $0xfa448948; BYTE $0x08 // movq %rax, $8(%rdx,%rdi,8) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0xfee5820f; WORD $0xffff // jb LBB34_4, $-283(%rip) + +LBB34_36: + WORD $0x294c; BYTE $0xd1 // subq %r10, %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + WORD $0xc031 // xorl %eax, %eax + +LBB34_37: + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB34_32: + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffffe4e9; BYTE $0xff // jmp LBB34_37, $-28(%rip) + +LBB34_17: + WORD $0x8948; BYTE $0x3e // movq %rdi, (%rsi) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffffd5e9; BYTE $0xff // jmp LBB34_37, $-43(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_validate_utf8_fast: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + LONG $0x1a348d4b // leaq (%r10,%r11), %rsi + LONG $0xfdc68348 // addq $-3, %rsi + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0x394c; BYTE $0xd6 // cmpq %r10, %rsi + LONG $0x00dd860f; WORD $0x0000 // jbe LBB35_14, $221(%rip) + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x000013e9; BYTE $0x00 // jmp LBB35_3, $19(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_2: + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x00c2830f; WORD $0x0000 // jae LBB35_14, $194(%rip) + +LBB35_3: + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) + LONG $0xffe6890f; WORD $0xffff // jns LBB35_2, $-26(%rip) + WORD $0x388b // movl (%rax), %edi + WORD $0xf989 // movl %edi, %ecx + LONG $0xc0f0e181; WORD $0x00c0 // andl $12632304, %ecx + LONG $0x80e0f981; WORD $0x0080 // cmpl $8421600, %ecx + LONG $0x0030850f; WORD $0x0000 // jne LBB35_7, $48(%rip) + WORD $0xf989 // movl %edi, %ecx + LONG $0x200fe181; WORD $0x0000 // andl $8207, %ecx + LONG $0x200df981; WORD $0x0000 // cmpl $8205, %ecx + LONG $0x001c840f; WORD $0x0000 // je LBB35_7, $28(%rip) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + WORD $0xc985 // testl %ecx, %ecx + LONG $0xffaf850f; WORD $0xffff // jne LBB35_2, $-81(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_7: + WORD $0xf989 // movl %edi, %ecx + LONG $0xc0e0e181; WORD $0x0000 // andl $49376, %ecx + LONG $0x80c0f981; WORD $0x0000 // cmpl $32960, %ecx + LONG $0x0010850f; WORD $0x0000 // jne LBB35_9, $16(%rip) + WORD $0xf989 // movl %edi, %ecx + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + WORD $0xe183; BYTE $0x1e // andl $30, %ecx + LONG $0xff7c850f; WORD $0xffff // jne LBB35_2, $-132(%rip) + +LBB35_9: + WORD $0xf989 // movl %edi, %ecx + LONG $0xc0f8e181; WORD $0xc0c0 // andl $-1061109512, %ecx + LONG $0x80f0f981; WORD $0x8080 // cmpl $-2139062032, %ecx + LONG $0x0029850f; WORD $0x0000 // jne LBB35_13, $41(%rip) + WORD $0xf989 // movl %edi, %ecx + LONG $0x3007e181; WORD $0x0000 // andl $12295, %ecx + LONG $0x001b840f; WORD $0x0000 // je LBB35_13, $27(%rip) + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + LONG $0x04c7f640 // testb $4, %dil + LONG $0xff4b840f; WORD $0xffff // je LBB35_2, $-181(%rip) + LONG $0x3003e781; WORD $0x0000 // andl $12291, %edi + LONG $0xff3f840f; WORD $0xffff // je LBB35_2, $-193(%rip) + +LBB35_13: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xd0 // addq %r10, %rax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB35_14: + WORD $0x014d; BYTE $0xd3 // addq %r10, %r11 + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x0103830f; WORD $0x0000 // jae LBB35_30, $259(%rip) + LONG $0xf4458d4c // leaq $-12(%rbp), %r8 + LONG $0xf24d8d4c // leaq $-14(%rbp), %r9 + LONG $0x000015e9; BYTE $0x00 // jmp LBB35_17, $21(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_16: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0x00e1830f; WORD $0x0000 // jae LBB35_30, $225(%rip) + +LBB35_17: + WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) + LONG $0xffeb890f; WORD $0xffff // jns LBB35_16, $-21(%rip) + LONG $0x00f445c6 // movb $0, $-12(%rbp) + LONG $0x00f245c6 // movb $0, $-14(%rbp) + WORD $0x894c; BYTE $0xda // movq %r11, %rdx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0031820f; WORD $0x0000 // jb LBB35_21, $49(%rip) + WORD $0xb60f; BYTE $0x30 // movzbl (%rax), %esi + LONG $0x0178b60f // movzbl $1(%rax), %edi + LONG $0xf4758840 // movb %sil, $-12(%rbp) + LONG $0x02488d48 // leaq $2(%rax), %rcx + LONG $0xfec28348 // addq $-2, %rdx + WORD $0x894c; BYTE $0xcb // movq %r9, %rbx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0025840f; WORD $0x0000 // je LBB35_22, $37(%rip) + +LBB35_20: + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + WORD $0x0b88 // movb %cl, (%rbx) + LONG $0xf475b60f // movzbl $-12(%rbp), %esi + LONG $0xf24db60f // movzbl $-14(%rbp), %ecx + LONG $0x000015e9; BYTE $0x00 // jmp LBB35_23, $21(%rip) + +LBB35_21: + WORD $0xf631 // xorl %esi, %esi + WORD $0xff31 // xorl %edi, %edi + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffdb850f; WORD $0xffff // jne LBB35_20, $-37(%rip) + +LBB35_22: + WORD $0xc931 // xorl %ecx, %ecx + +LBB35_23: + WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx + WORD $0xe1c1; BYTE $0x10 // shll $16, %ecx + LONG $0xffb60f40 // movzbl %dil, %edi + WORD $0xe7c1; BYTE $0x08 // shll $8, %edi + WORD $0xcf09 // orl %ecx, %edi + LONG $0xd6b60f40 // movzbl %sil, %edx + WORD $0xfa09 // orl %edi, %edx + WORD $0xd189 // movl %edx, %ecx + LONG $0xc0f0e181; WORD $0x00c0 // andl $12632304, %ecx + LONG $0x80e0f981; WORD $0x0080 // cmpl $8421600, %ecx + LONG $0x0024850f; WORD $0x0000 // jne LBB35_26, $36(%rip) + WORD $0xd789 // movl %edx, %edi + LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi + LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi + LONG $0x0010840f; WORD $0x0000 // je LBB35_26, $16(%rip) + LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx + WORD $0xff85 // testl %edi, %edi + LONG $0x0024850f; WORD $0x0000 // jne LBB35_28, $36(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB35_26: + LONG $0x1ec6f640 // testb $30, %sil + LONG $0xff07840f; WORD $0xffff // je LBB35_13, $-249(%rip) + LONG $0xc0e0e281; WORD $0x0000 // andl $49376, %edx + LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx + LONG $0x80c0fa81; WORD $0x0000 // cmpl $32960, %edx + LONG $0xfef0850f; WORD $0xffff // jne LBB35_13, $-272(%rip) + +LBB35_28: + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + LONG $0xff1f820f; WORD $0xffff // jb LBB35_17, $-225(%rip) + +LBB35_30: + WORD $0xc031 // xorl %eax, %eax + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI36_0: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x90 +_f32toa: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + LONG $0xc07e0f66 // movd %xmm0, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x17 // shrl $23, %ecx + WORD $0xb60f; BYTE $0xd1 // movzbl %cl, %edx + LONG $0x00fffa81; WORD $0x0000 // cmpl $255, %edx + LONG $0x0c90840f; WORD $0x0000 // je LBB36_1, $3216(%rip) + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0x8941; BYTE $0xc5 // movl %eax, %r13d + LONG $0x1fedc141 // shrl $31, %r13d + LONG $0x2f0c8d4e // leaq (%rdi,%r13), %r9 + LONG $0xffffffa9; BYTE $0x7f // testl $2147483647, %eax + LONG $0x0191840f; WORD $0x0000 // je LBB36_3, $401(%rip) + LONG $0x7fffff25; BYTE $0x00 // andl $8388607, %eax + WORD $0xd285 // testl %edx, %edx + LONG $0x0c71840f; WORD $0x0000 // je LBB36_5, $3185(%rip) + LONG $0x00b88d44; WORD $0x8000; BYTE $0x00 // leal $8388608(%rax), %r15d + LONG $0x6a828d44; WORD $0xffff; BYTE $0xff // leal $-150(%rdx), %r8d + WORD $0x4a8d; BYTE $0x81 // leal $-127(%rdx), %ecx + WORD $0xf983; BYTE $0x17 // cmpl $23, %ecx + LONG $0x001c870f; WORD $0x0000 // ja LBB36_6, $28(%rip) + LONG $0x000096b9; BYTE $0x00 // movl $150, %ecx + WORD $0xd129 // subl %edx, %ecx + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx + WORD $0xd3f7 // notl %ebx + WORD $0x8544; BYTE $0xfb // testl %r15d, %ebx + LONG $0x0303840f; WORD $0x0000 // je LBB36_11, $771(%rip) + +LBB36_6: + WORD $0x8945; BYTE $0xfe // movl %r15d, %r14d + LONG $0x01e68341 // andl $1, %r14d + WORD $0xc085 // testl %eax, %eax + WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0xfa83; BYTE $0x02 // cmpl $2, %edx + WORD $0x930f; BYTE $0xc1 // setae %cl + WORD $0xc120 // andb %al, %cl + WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx + WORD $0x8945; BYTE $0xfa // movl %r15d, %r10d + LONG $0x02e2c141 // shll $2, %r10d + LONG $0xb9048d42 // leal (%rcx,%r15,4), %eax + WORD $0xc083; BYTE $0xfe // addl $-2, %eax + LONG $0x13d06941; WORD $0x1344; BYTE $0x00 // imull $1262611, %r8d, %edx + LONG $0x019a8d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rdx), %r11d + WORD $0xc984 // testb %cl, %cl + LONG $0xda440f44 // cmovel %edx, %r11d + LONG $0x16fbc141 // sarl $22, %r11d + LONG $0xb1cb6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r11d, %ecx + WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx + WORD $0x0144; BYTE $0xc1 // addl %r8d, %ecx + LONG $0x00001fba; BYTE $0x00 // movl $31, %edx + WORD $0x2944; BYTE $0xda // subl %r11d, %edx + LONG $0x65358d48; WORD $0x00b7; BYTE $0x00 // leaq $46949(%rip), %rsi /* _pow10_ceil_sig_f32.g(%rip) */ + WORD $0xc1fe // incb %cl + WORD $0xe0d3 // shll %cl, %eax + LONG $0xd6248b4c // movq (%rsi,%rdx,8), %r12 + WORD $0xf749; BYTE $0xe4 // mulq %r12 + QUAD $0x00000002bd048d46 // leal $2(,%r15,4), %r8d + WORD $0xf631 // xorl %esi, %esi + LONG $0x21e8c148 // shrq $33, %rax + LONG $0xc6950f40 // setne %sil + WORD $0xd609 // orl %edx, %esi + WORD $0xd341; BYTE $0xe2 // shll %cl, %r10d + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0xf749; BYTE $0xe4 // mulq %r12 + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + LONG $0x21e8c148 // shrq $33, %rax + LONG $0xc7950f41 // setne %r15b + WORD $0x0945; BYTE $0xd7 // orl %r10d, %r15d + WORD $0xd341; BYTE $0xe0 // shll %cl, %r8d + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0xf749; BYTE $0xe4 // mulq %r12 + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x21e8c148 // shrq $33, %rax + WORD $0x950f; BYTE $0xc1 // setne %cl + WORD $0xd109 // orl %edx, %ecx + WORD $0x0144; BYTE $0xf6 // addl %r14d, %esi + WORD $0x2944; BYTE $0xf1 // subl %r14d, %ecx + LONG $0x28ff8341 // cmpl $40, %r15d + LONG $0x0042820f; WORD $0x0000 // jb LBB36_26, $66(%rip) + WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax + LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx + LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d + QUAD $0x00000000d51c8d48 // leaq (,%rdx,8), %rbx + LONG $0x9b048d48 // leaq (%rbx,%rbx,4), %rax + WORD $0x394c; BYTE $0xc0 // cmpq %r8, %rax + LONG $0xc6920f41 // setb %r14b + LONG $0x9b048d4c // leaq (%rbx,%rbx,4), %r8 + LONG $0x28c08349 // addq $40, %r8 + WORD $0xcb89 // movl %ecx, %ebx + WORD $0xc031 // xorl %eax, %eax + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0xc0960f41 // setbe %r8b + WORD $0x3845; BYTE $0xc6 // cmpb %r8b, %r14b + LONG $0x00b3840f; WORD $0x0000 // je LBB36_8, $179(%rip) + +LBB36_26: + WORD $0x8945; BYTE $0xd0 // movl %r10d, %r8d + LONG $0x02e8c141 // shrl $2, %r8d + WORD $0x8944; BYTE $0xd2 // movl %r10d, %edx + WORD $0xe283; BYTE $0xfc // andl $-4, %edx + WORD $0xd639 // cmpl %edx, %esi + LONG $0xc6970f40 // seta %sil + WORD $0x428d; BYTE $0x04 // leal $4(%rdx), %eax + WORD $0xc839 // cmpl %ecx, %eax + WORD $0x960f; BYTE $0xc3 // setbe %bl + WORD $0x3040; BYTE $0xf3 // xorb %sil, %bl + LONG $0x0044840f; WORD $0x0000 // je LBB36_27, $68(%rip) + WORD $0xca83; BYTE $0x02 // orl $2, %edx + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x3941; BYTE $0xd7 // cmpl %edx, %r15d + LONG $0x000e870f; WORD $0x0000 // ja LBB36_30, $14(%rip) + WORD $0x940f; BYTE $0xc0 // sete %al + LONG $0x02eac041 // shrb $2, %r10b + WORD $0x2041; BYTE $0xc2 // andb %al, %r10b + LONG $0xc2b60f41 // movzbl %r10b, %eax + +LBB36_30: + WORD $0x0144; BYTE $0xc0 // addl %r8d, %eax + LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax + LONG $0x002b830f; WORD $0x0000 // jae LBB36_32, $43(%rip) + LONG $0x000070e9; BYTE $0x00 // jmp LBB36_35, $112(%rip) + +LBB36_3: + LONG $0x3001c641 // movb $48, (%r9) + WORD $0x2941; BYTE $0xf9 // subl %edi, %r9d + WORD $0xff41; BYTE $0xc1 // incl %r9d + WORD $0x8944; BYTE $0xc8 // movl %r9d, %eax + LONG $0x0006b3e9; BYTE $0x00 // jmp LBB36_147, $1715(%rip) + +LBB36_27: + WORD $0xc139 // cmpl %eax, %ecx + LONG $0xffd88341 // sbbl $-1, %r8d + WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax + LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax + LONG $0x004a820f; WORD $0x0000 // jb LBB36_35, $74(%rip) + +LBB36_32: + LONG $0x0006be41; WORD $0x0000 // movl $6, %r14d + LONG $0x0f42403d; BYTE $0x00 // cmpl $1000000, %eax + LONG $0x0078820f; WORD $0x0000 // jb LBB36_39, $120(%rip) + LONG $0x0007be41; WORD $0x0000 // movl $7, %r14d + LONG $0x9896803d; BYTE $0x00 // cmpl $10000000, %eax + LONG $0x0067820f; WORD $0x0000 // jb LBB36_39, $103(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0xf5e1003d; BYTE $0x05 // cmpl $100000000, %eax + LONG $0xc6920f41 // setb %r14b + LONG $0x09f68341 // xorl $9, %r14d + LONG $0x000052e9; BYTE $0x00 // jmp LBB36_39, $82(%rip) + +LBB36_8: + WORD $0x8844; BYTE $0xc0 // movb %r8b, %al + WORD $0xd001 // addl %edx, %eax + WORD $0xff41; BYTE $0xc3 // incl %r11d + LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax + LONG $0xffb6830f; WORD $0xffff // jae LBB36_32, $-74(%rip) + +LBB36_35: + LONG $0x0001be41; WORD $0x0000 // movl $1, %r14d + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x0030820f; WORD $0x0000 // jb LBB36_39, $48(%rip) + LONG $0x0002be41; WORD $0x0000 // movl $2, %r14d + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0x0021820f; WORD $0x0000 // jb LBB36_39, $33(%rip) + LONG $0x0003be41; WORD $0x0000 // movl $3, %r14d + LONG $0x0003e83d; BYTE $0x00 // cmpl $1000, %eax + LONG $0x0010820f; WORD $0x0000 // jb LBB36_39, $16(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0xc6920f41 // setb %r14b + LONG $0x05f68341 // xorl $5, %r14d + +LBB36_39: + LONG $0x1e148d47 // leal (%r14,%r11), %r10d + LONG $0x1e0c8d43 // leal (%r14,%r11), %ecx + WORD $0xc183; BYTE $0xea // addl $-22, %ecx + WORD $0xf983; BYTE $0xe4 // cmpl $-28, %ecx + LONG $0x0069870f; WORD $0x0000 // ja LBB36_64, $105(%rip) + WORD $0x8945; BYTE $0xf6 // movl %r14d, %r14d + LONG $0x31148d4b // leaq (%r9,%r14), %rdx + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0x00c8820f; WORD $0x0000 // jb LBB36_41, $200(%rip) + WORD $0xc389 // movl %eax, %ebx + LONG $0xb71759b9; BYTE $0xd1 // movl $3518437209, %ecx + LONG $0xcbaf0f48 // imulq %rbx, %rcx + LONG $0x2de9c148 // shrq $45, %rcx + LONG $0xf0c16944; WORD $0xffd8; BYTE $0xff // imull $-10000, %ecx, %r8d + WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d + LONG $0x02f8840f; WORD $0x0000 // je LBB36_43, $760(%rip) + WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx + WORD $0x2941; BYTE $0xd8 // subl %ebx, %r8d + LONG $0xde1d8d4c; WORD $0x0041; BYTE $0x00 // leaq $16862(%rip), %r11 /* _Digits(%rip) */ + LONG $0x1cb70f43; BYTE $0x43 // movzwl (%r11,%r8,2), %ebx + LONG $0xfe5a8966 // movw %bx, $-2(%rdx) + LONG $0x04b70f41; BYTE $0x43 // movzwl (%r11,%rax,2), %eax + LONG $0xfc428966 // movw %ax, $-4(%rdx) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0x0002c9e9; BYTE $0x00 // jmp LBB36_45, $713(%rip) + +LBB36_64: + WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x0109880f; WORD $0x0000 // js LBB36_65, $265(%rip) + LONG $0x213c8d4f // leaq (%r9,%r12), %r15 + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0x0136820f; WORD $0x0000 // jb LBB36_118, $310(%rip) + WORD $0xc189 // movl %eax, %ecx + LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx + LONG $0xd1af0f48 // imulq %rcx, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0xd8f0ca69; WORD $0xffff // imull $-10000, %edx, %ecx + WORD $0xc101 // addl %eax, %ecx + LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx + WORD $0xd929 // subl %ebx, %ecx + LONG $0x7b1d8d48; WORD $0x0041; BYTE $0x00 // leaq $16763(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4b0cb70f // movzwl (%rbx,%rcx,2), %ecx + LONG $0x4f894166; BYTE $0xfe // movw %cx, $-2(%r15) + LONG $0xfc4f8d49 // leaq $-4(%r15), %rcx + LONG $0x4304b70f // movzwl (%rbx,%rax,2), %eax + LONG $0x47894166; BYTE $0xfc // movw %ax, $-4(%r15) + WORD $0xd089 // movl %edx, %eax + WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0x00f3830f; WORD $0x0000 // jae LBB36_122, $243(%rip) + +LBB36_121: + WORD $0xc289 // movl %eax, %edx + LONG $0x00012ee9; BYTE $0x00 // jmp LBB36_124, $302(%rip) + +LBB36_41: + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xc189 // movl %eax, %ecx + WORD $0xf983; BYTE $0x64 // cmpl $100, %ecx + LONG $0x0254830f; WORD $0x0000 // jae LBB36_48, $596(%rip) + +LBB36_47: + WORD $0xc889 // movl %ecx, %eax + LONG $0x00028ae9; BYTE $0x00 // jmp LBB36_50, $650(%rip) + +LBB36_11: + WORD $0xd341; BYTE $0xef // shrl %cl, %r15d + LONG $0xa0ff8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r15d + LONG $0x017d820f; WORD $0x0000 // jb LBB36_14, $381(%rip) + LONG $0x80ff8141; WORD $0x9896; BYTE $0x00 // cmpl $10000000, %r15d + LONG $0x000008b8; BYTE $0x00 // movl $8, %eax + LONG $0x00d88348 // sbbq $0, %rax + LONG $0x40ff8141; WORD $0x0f42; BYTE $0x00 // cmpl $1000000, %r15d + LONG $0x000006b9; BYTE $0x00 // movl $6, %ecx + LONG $0xc8430f48 // cmovaeq %rax, %rcx + WORD $0x014c; BYTE $0xc9 // addq %r9, %rcx + +LBB36_13: + WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax + LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx + LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0xd8f0c269; WORD $0xffff // imull $-10000, %edx, %eax + WORD $0x0144; BYTE $0xf8 // addl %r15d, %eax + LONG $0x1ff06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rsi + LONG $0x25eec148 // shrq $37, %rsi + WORD $0xde6b; BYTE $0x64 // imull $100, %esi, %ebx + WORD $0xd829 // subl %ebx, %eax + LONG $0xd81d8d48; WORD $0x0040; BYTE $0x00 // leaq $16600(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4304b70f // movzwl (%rbx,%rax,2), %eax + LONG $0xfe418966 // movw %ax, $-2(%rcx) + LONG $0x7304b70f // movzwl (%rbx,%rsi,2), %eax + LONG $0xfc418966 // movw %ax, $-4(%rcx) + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xfcc18348 // addq $-4, %rcx + WORD $0x8941; BYTE $0xd7 // movl %edx, %r15d + LONG $0x64ff8341 // cmpl $100, %r15d + LONG $0x0146830f; WORD $0x0000 // jae LBB36_21, $326(%rip) + LONG $0x000181e9; BYTE $0x00 // jmp LBB36_23, $385(%rip) + +LBB36_65: + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x05458f0f; WORD $0x0000 // jg LBB36_79, $1349(%rip) + LONG $0x01c74166; WORD $0x2e30 // movw $11824, (%r9) + LONG $0x02c18349 // addq $2, %r9 + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0532890f; WORD $0x0000 // jns LBB36_79, $1330(%rip) + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d + WORD $0xf741; BYTE $0xd4 // notl %r12d + WORD $0x2945; BYTE $0xdc // subl %r11d, %r12d + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x1ffc8341 // cmpl $31, %r12d + LONG $0x0402830f; WORD $0x0000 // jae LBB36_69, $1026(%rip) + WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 + LONG $0x0004f2e9; BYTE $0x00 // jmp LBB36_77, $1266(%rip) + +LBB36_118: + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d + WORD $0xf883; BYTE $0x64 // cmpl $100, %eax + LONG $0xff0d820f; WORD $0xffff // jb LBB36_121, $-243(%rip) + +LBB36_122: + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0x5a058d4c; WORD $0x0040; BYTE $0x00 // leaq $16474(%rip), %r8 /* _Digits(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB36_123: + WORD $0xc289 // movl %eax, %edx + LONG $0x1fd26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xda6b; BYTE $0x64 // imull $100, %edx, %ebx + WORD $0xc689 // movl %eax, %esi + WORD $0xde29 // subl %ebx, %esi + LONG $0x34b70f41; BYTE $0x70 // movzwl (%r8,%rsi,2), %esi + LONG $0xff718966 // movw %si, $-1(%rcx) + LONG $0xfec18348 // addq $-2, %rcx + LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax + WORD $0xd089 // movl %edx, %eax + LONG $0xffd2870f; WORD $0xffff // ja LBB36_123, $-46(%rip) + +LBB36_124: + WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx + LONG $0x0022820f; WORD $0x0000 // jb LBB36_126, $34(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x100d8d48; WORD $0x0040; BYTE $0x00 // leaq $16400(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x01894166 // movw %ax, (%r9) + WORD $0x014d; BYTE $0xd9 // addq %r11, %r9 + WORD $0x3945; BYTE $0xd6 // cmpl %r10d, %r14d + LONG $0x0017820f; WORD $0x0000 // jb LBB36_128, $23(%rip) + LONG $0x0003c7e9; BYTE $0x00 // jmp LBB36_145, $967(%rip) + +LBB36_126: + WORD $0xc280; BYTE $0x30 // addb $48, %dl + WORD $0x8841; BYTE $0x11 // movb %dl, (%r9) + WORD $0x014d; BYTE $0xd9 // addq %r11, %r9 + WORD $0x3945; BYTE $0xd6 // cmpl %r10d, %r14d + LONG $0x03b5830f; WORD $0x0000 // jae LBB36_145, $949(%rip) + +LBB36_128: + LONG $0x2f048d4a // leaq (%rdi,%r13), %rax + LONG $0x040c8d49 // leaq (%r12,%rax), %rcx + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0xd9470f4c // cmovaq %rcx, %r11 + WORD $0x014c; BYTE $0xe0 // addq %r12, %rax + WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 + LONG $0x08fb8349 // cmpq $8, %r11 + LONG $0x0380820f; WORD $0x0000 // jb LBB36_144, $896(%rip) + LONG $0x20fb8349 // cmpq $32, %r11 + LONG $0x01e5830f; WORD $0x0000 // jae LBB36_134, $485(%rip) + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x0002c9e9; BYTE $0x00 // jmp LBB36_131, $713(%rip) + +LBB36_14: + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x0aff8341 // cmpl $10, %r15d + LONG $0x0021820f; WORD $0x0000 // jb LBB36_17, $33(%rip) + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + LONG $0x64ff8341 // cmpl $100, %r15d + LONG $0x0012820f; WORD $0x0000 // jb LBB36_17, $18(%rip) + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + LONG $0xe7ff8141; WORD $0x0003; BYTE $0x00 // cmpl $999, %r15d + LONG $0x02de870f; WORD $0x0000 // ja LBB36_19, $734(%rip) + +LBB36_17: + WORD $0x014c; BYTE $0xc8 // addq %r9, %rax + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + LONG $0x64ff8341 // cmpl $100, %r15d + LONG $0x0040820f; WORD $0x0000 // jb LBB36_23, $64(%rip) + +LBB36_21: + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0x64058d4c; WORD $0x003f; BYTE $0x00 // leaq $16228(%rip), %r8 /* _Digits(%rip) */ + LONG $0x90909090 // .p2align 4, 0x90 + +LBB36_22: + WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx + WORD $0x8944; BYTE $0xfe // movl %r15d, %esi + LONG $0x1ffe694c; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %r15 + LONG $0x25efc149 // shrq $37, %r15 + LONG $0x64d76b41 // imull $100, %r15d, %edx + WORD $0xde89 // movl %ebx, %esi + WORD $0xd629 // subl %edx, %esi + LONG $0x14b70f41; BYTE $0x70 // movzwl (%r8,%rsi,2), %edx + LONG $0xff518966 // movw %dx, $-1(%rcx) + LONG $0xfec18348 // addq $-2, %rcx + LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx + LONG $0xffce870f; WORD $0xffff // ja LBB36_22, $-50(%rip) + +LBB36_23: + LONG $0x0aff8341 // cmpl $10, %r15d + LONG $0x0017820f; WORD $0x0000 // jb LBB36_25, $23(%rip) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + LONG $0x1a158d48; WORD $0x003f; BYTE $0x00 // leaq $16154(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x09894166 // movw %cx, (%r9) + LONG $0x0002e0e9; BYTE $0x00 // jmp LBB36_146, $736(%rip) + +LBB36_25: + LONG $0x30c78041 // addb $48, %r15b + WORD $0x8845; BYTE $0x39 // movb %r15b, (%r9) + LONG $0x0002d4e9; BYTE $0x00 // jmp LBB36_146, $724(%rip) + +LBB36_43: + LONG $0x0004b841; WORD $0x0000 // movl $4, %r8d + +LBB36_45: + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0xf983; BYTE $0x64 // cmpl $100, %ecx + LONG $0xfdac820f; WORD $0xffff // jb LBB36_47, $-596(%rip) + +LBB36_48: + WORD $0xff48; BYTE $0xca // decq %rdx + LONG $0xe41d8d4c; WORD $0x003e; BYTE $0x00 // leaq $16100(%rip), %r11 /* _Digits(%rip) */ + LONG $0x90909090 // .p2align 4, 0x90 + +LBB36_49: + WORD $0xc889 // movl %ecx, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx + WORD $0xce89 // movl %ecx, %esi + WORD $0xde29 // subl %ebx, %esi + LONG $0x34b70f41; BYTE $0x73 // movzwl (%r11,%rsi,2), %esi + LONG $0xff728966 // movw %si, $-1(%rdx) + LONG $0xfec28348 // addq $-2, %rdx + LONG $0x270ff981; WORD $0x0000 // cmpl $9999, %ecx + WORD $0xc189 // movl %eax, %ecx + LONG $0xffd1870f; WORD $0xffff // ja LBB36_49, $-47(%rip) + +LBB36_50: + LONG $0x01518d49 // leaq $1(%r9), %rdx + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x001f820f; WORD $0x0000 // jb LBB36_52, $31(%rip) + WORD $0xc189 // movl %eax, %ecx + LONG $0x9b358d48; WORD $0x003e; BYTE $0x00 // leaq $16027(%rip), %rsi /* _Digits(%rip) */ + LONG $0x4e04b60f // movzbl (%rsi,%rcx,2), %eax + LONG $0x4e4cb60f; BYTE $0x01 // movzbl $1(%rsi,%rcx,2), %ecx + LONG $0x01418841 // movb %al, $1(%r9) + LONG $0x02498841 // movb %cl, $2(%r9) + LONG $0x000004e9; BYTE $0x00 // jmp LBB36_53, $4(%rip) + +LBB36_52: + WORD $0x3004 // addb $48, %al + WORD $0x0288 // movb %al, (%rdx) + +LBB36_53: + WORD $0x294d; BYTE $0xc5 // subq %r8, %r13 + WORD $0x0149; BYTE $0xfd // addq %rdi, %r13 + LONG $0x000001be; BYTE $0x00 // movl $1, %esi + WORD $0x294c; BYTE $0xc6 // subq %r8, %rsi + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_54: + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x357c8043; WORD $0x3000 // cmpb $48, (%r13,%r14) + LONG $0xff6d8d4d // leaq $-1(%r13), %r13 + LONG $0xffed840f; WORD $0xffff // je LBB36_54, $-19(%rip) + WORD $0x8841; BYTE $0x01 // movb %al, (%r9) + WORD $0x014c; BYTE $0xf6 // addq %r14, %rsi + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x00458c0f; WORD $0x0000 // jl LBB36_56, $69(%rip) + LONG $0x2e048d4b // leaq (%r14,%r13), %rax + LONG $0x02c08348 // addq $2, %rax + WORD $0x02c6; BYTE $0x2e // movb $46, (%rdx) + WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00418e0f; WORD $0x0000 // jle LBB36_59, $65(%rip) + +LBB36_60: + WORD $0xff41; BYTE $0xca // decl %r10d + LONG $0x2b0140c6 // movb $43, $1(%rax) + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0x0043820f; WORD $0x0000 // jb LBB36_63, $67(%rip) + +LBB36_62: + WORD $0x6348; BYTE $0xc9 // movslq %ecx, %rcx + LONG $0x19158d48; WORD $0x003e; BYTE $0x00 // leaq $15897(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x02488966 // movw %cx, $2(%rax) + LONG $0x04c08348 // addq $4, %rax + LONG $0x0001dbe9; BYTE $0x00 // jmp LBB36_146, $475(%rip) + +LBB36_56: + LONG $0x2e048d4b // leaq (%r14,%r13), %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0xffbf8f0f; WORD $0xffff // jg LBB36_60, $-65(%rip) + +LBB36_59: + LONG $0x2d0140c6 // movb $45, $1(%rax) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + WORD $0x2944; BYTE $0xd1 // subl %r10d, %ecx + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0xffbd830f; WORD $0xffff // jae LBB36_62, $-67(%rip) + +LBB36_63: + WORD $0xc180; BYTE $0x30 // addb $48, %cl + WORD $0x4888; BYTE $0x02 // movb %cl, $2(%rax) + LONG $0x03c08348 // addq $3, %rax + LONG $0x0001a4e9; BYTE $0x00 // jmp LBB36_146, $420(%rip) + +LBB36_134: + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xe0e28349 // andq $-32, %r10 + LONG $0xe0428d49 // leaq $-32(%r10), %rax + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + LONG $0x05e9c148 // shrq $5, %rcx + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x8941; BYTE $0xc8 // movl %ecx, %r8d + LONG $0x03e08341 // andl $3, %r8d + LONG $0x60f88348 // cmpq $96, %rax + LONG $0x0007830f; WORD $0x0000 // jae LBB36_136, $7(%rip) + WORD $0xc031 // xorl %eax, %eax + LONG $0x000061e9; BYTE $0x00 // jmp LBB36_138, $97(%rip) + +LBB36_136: + LONG $0xfce18348 // andq $-4, %rcx + LONG $0x2c048d4b // leaq (%r12,%r13), %rax + LONG $0x07148d48 // leaq (%rdi,%rax), %rdx + LONG $0x70c28348 // addq $112, %rdx + WORD $0xc031 // xorl %eax, %eax + QUAD $0xfffff8ba056f0f66 // movdqa $-1862(%rip), %xmm0 /* LCPI36_0(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB36_137: + LONG $0x447f0ff3; WORD $0x9002 // movdqu %xmm0, $-112(%rdx,%rax) + LONG $0x447f0ff3; WORD $0xa002 // movdqu %xmm0, $-96(%rdx,%rax) + LONG $0x447f0ff3; WORD $0xb002 // movdqu %xmm0, $-80(%rdx,%rax) + LONG $0x447f0ff3; WORD $0xc002 // movdqu %xmm0, $-64(%rdx,%rax) + LONG $0x447f0ff3; WORD $0xd002 // movdqu %xmm0, $-48(%rdx,%rax) + LONG $0x447f0ff3; WORD $0xe002 // movdqu %xmm0, $-32(%rdx,%rax) + LONG $0x447f0ff3; WORD $0xf002 // movdqu %xmm0, $-16(%rdx,%rax) + LONG $0x047f0ff3; BYTE $0x02 // movdqu %xmm0, (%rdx,%rax) + LONG $0x80e88348 // subq $-128, %rax + LONG $0xfcc18348 // addq $-4, %rcx + LONG $0xffc3850f; WORD $0xffff // jne LBB36_137, $-61(%rip) + +LBB36_138: + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x0042840f; WORD $0x0000 // je LBB36_141, $66(%rip) + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + WORD $0x014c; BYTE $0xe0 // addq %r12, %rax + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + LONG $0x10c08348 // addq $16, %rax + LONG $0x05e0c149 // shlq $5, %r8 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0xfffff84f056f0f66 // movdqa $-1969(%rip), %xmm0 /* LCPI36_0(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_140: + LONG $0x447f0ff3; WORD $0xf008 // movdqu %xmm0, $-16(%rax,%rcx) + LONG $0x047f0ff3; BYTE $0x08 // movdqu %xmm0, (%rax,%rcx) + LONG $0x20c18348 // addq $32, %rcx + WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 + LONG $0xffe8850f; WORD $0xffff // jne LBB36_140, $-24(%rip) + +LBB36_141: + WORD $0x394d; BYTE $0xd3 // cmpq %r10, %r11 + LONG $0x00bf840f; WORD $0x0000 // je LBB36_145, $191(%rip) + LONG $0x18c3f641 // testb $24, %r11b + LONG $0x009c840f; WORD $0x0000 // je LBB36_143, $156(%rip) + +LBB36_131: + WORD $0x894d; BYTE $0xd8 // movq %r11, %r8 + LONG $0xf8e08349 // andq $-8, %r8 + WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 + WORD $0x014d; BYTE $0xd5 // addq %r10, %r13 + WORD $0x014d; BYTE $0xe5 // addq %r12, %r13 + WORD $0x0149; BYTE $0xfd // addq %rdi, %r13 + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + WORD $0x294c; BYTE $0xd1 // subq %r10, %rcx + WORD $0xd231 // xorl %edx, %edx + QUAD $0x303030303030b848; WORD $0x3030 // movabsq $3472328296227680304, %rax + + // .p2align 4, 0x90 +LBB36_132: + LONG $0x15448949; BYTE $0x00 // movq %rax, (%r13,%rdx) + LONG $0x08c28348 // addq $8, %rdx + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0xffee850f; WORD $0xffff // jne LBB36_132, $-18(%rip) + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0x0065850f; WORD $0x0000 // jne LBB36_144, $101(%rip) + LONG $0x000070e9; BYTE $0x00 // jmp LBB36_145, $112(%rip) + +LBB36_19: + LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d + WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx + LONG $0x00d98348 // sbbq $0, %rcx + LONG $0x05c18348 // addq $5, %rcx + LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d + LONG $0xfb79830f; WORD $0xffff // jae LBB36_13, $-1159(%rip) + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xfffd0be9; BYTE $0xff // jmp LBB36_21, $-757(%rip) + +LBB36_69: + WORD $0xff49; BYTE $0xc4 // incq %r12 + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + LONG $0xe0e18348 // andq $-32, %rcx + LONG $0xe0518d48 // leaq $-32(%rcx), %rdx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + LONG $0x05e8c149 // shrq $5, %r8 + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x8945; BYTE $0xc7 // movl %r8d, %r15d + LONG $0x03e78341 // andl $3, %r15d + LONG $0x60fa8348 // cmpq $96, %rdx + LONG $0x0034830f; WORD $0x0000 // jae LBB36_71, $52(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x000080e9; BYTE $0x00 // jmp LBB36_73, $128(%rip) + +LBB36_143: + WORD $0x014d; BYTE $0xd7 // addq %r10, %r15 + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB36_144: + LONG $0x3007c641 // movb $48, (%r15) + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0x394d; BYTE $0xcf // cmpq %r9, %r15 + LONG $0xfff0820f; WORD $0xffff // jb LBB36_144, $-16(%rip) + +LBB36_145: + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + +LBB36_146: + WORD $0xf829 // subl %edi, %eax + +LBB36_147: + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB36_71: + LONG $0xfce08349 // andq $-4, %r8 + LONG $0x2f348d4a // leaq (%rdi,%r13), %rsi + LONG $0x72c68348 // addq $114, %rsi + WORD $0xd231 // xorl %edx, %edx + QUAD $0xfffff736056f0f66 // movdqa $-2250(%rip), %xmm0 /* LCPI36_0(%rip) */ + +LBB36_72: + LONG $0x447f0ff3; WORD $0x9016 // movdqu %xmm0, $-112(%rsi,%rdx) + LONG $0x447f0ff3; WORD $0xa016 // movdqu %xmm0, $-96(%rsi,%rdx) + LONG $0x447f0ff3; WORD $0xb016 // movdqu %xmm0, $-80(%rsi,%rdx) + LONG $0x447f0ff3; WORD $0xc016 // movdqu %xmm0, $-64(%rsi,%rdx) + LONG $0x447f0ff3; WORD $0xd016 // movdqu %xmm0, $-48(%rsi,%rdx) + LONG $0x447f0ff3; WORD $0xe016 // movdqu %xmm0, $-32(%rsi,%rdx) + LONG $0x447f0ff3; WORD $0xf016 // movdqu %xmm0, $-16(%rsi,%rdx) + LONG $0x047f0ff3; BYTE $0x16 // movdqu %xmm0, (%rsi,%rdx) + LONG $0x80ea8348 // subq $-128, %rdx + LONG $0xfcc08349 // addq $-4, %r8 + LONG $0xffc3850f; WORD $0xffff // jne LBB36_72, $-61(%rip) + +LBB36_73: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0030840f; WORD $0x0000 // je LBB36_76, $48(%rip) + WORD $0x014c; BYTE $0xea // addq %r13, %rdx + WORD $0x0148; BYTE $0xfa // addq %rdi, %rdx + LONG $0x12c28348 // addq $18, %rdx + LONG $0x05e7c149 // shlq $5, %r15 + WORD $0xf631 // xorl %esi, %esi + QUAD $0xfffff6d8056f0f66 // movdqa $-2344(%rip), %xmm0 /* LCPI36_0(%rip) */ + +LBB36_75: + LONG $0x447f0ff3; WORD $0xf032 // movdqu %xmm0, $-16(%rdx,%rsi) + LONG $0x047f0ff3; BYTE $0x32 // movdqu %xmm0, (%rdx,%rsi) + LONG $0x20c68348 // addq $32, %rsi + WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 + LONG $0xffe8850f; WORD $0xffff // jne LBB36_75, $-24(%rip) + +LBB36_76: + WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 + WORD $0x3949; BYTE $0xcc // cmpq %rcx, %r12 + WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 + LONG $0x0020840f; WORD $0x0000 // je LBB36_79, $32(%rip) + +LBB36_77: + WORD $0x0144; BYTE $0xd1 // addl %r10d, %ecx + WORD $0xd9f7 // negl %ecx + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB36_78: + LONG $0x3001c641 // movb $48, (%r9) + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0xc9ff // decl %ecx + LONG $0xfff1850f; WORD $0xffff // jne LBB36_78, $-15(%rip) + +LBB36_79: + WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 + LONG $0x213c8d4f // leaq (%r9,%r12), %r15 + LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax + LONG $0x0052820f; WORD $0x0000 // jb LBB36_80, $82(%rip) + WORD $0xc289 // movl %eax, %edx + LONG $0x1759bc41; WORD $0xd1b7 // movl $3518437209, %r12d + LONG $0xe2af0f4c // imulq %rdx, %r12 + LONG $0x2decc149 // shrq $45, %r12 + LONG $0xf0d46941; WORD $0xffd8; BYTE $0xff // imull $-10000, %r12d, %edx + WORD $0xc201 // addl %eax, %edx + LONG $0x004e840f; WORD $0x0000 // je LBB36_82, $78(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xf06b; BYTE $0x64 // imull $100, %eax, %esi + WORD $0xf229 // subl %esi, %edx + LONG $0x17358d48; WORD $0x003b; BYTE $0x00 // leaq $15127(%rip), %rsi /* _Digits(%rip) */ + LONG $0x5614b70f // movzwl (%rsi,%rdx,2), %edx + LONG $0x57894166; BYTE $0xfe // movw %dx, $-2(%r15) + LONG $0x4604b70f // movzwl (%rsi,%rax,2), %eax + LONG $0x47894166; BYTE $0xfc // movw %ax, $-4(%r15) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0x000021e9; BYTE $0x00 // jmp LBB36_84, $33(%rip) + +LBB36_80: + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0x8941; BYTE $0xc4 // movl %eax, %r12d + LONG $0x64fc8341 // cmpl $100, %r12d + LONG $0x001c830f; WORD $0x0000 // jae LBB36_87, $28(%rip) + +LBB36_86: + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + LONG $0x000054e9; BYTE $0x00 // jmp LBB36_89, $84(%rip) + +LBB36_82: + LONG $0x0004b841; WORD $0x0000 // movl $4, %r8d + +LBB36_84: + LONG $0xfc778d49 // leaq $-4(%r15), %rsi + LONG $0x64fc8341 // cmpl $100, %r12d + LONG $0xffe4820f; WORD $0xffff // jb LBB36_86, $-28(%rip) + +LBB36_87: + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0xc4158d48; WORD $0x003a; BYTE $0x00 // leaq $15044(%rip), %rdx /* _Digits(%rip) */ + LONG $0x90909090 // .p2align 4, 0x90 + +LBB36_88: + WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax + LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax + LONG $0x25e8c148 // shrq $37, %rax + WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx + WORD $0x8944; BYTE $0xe1 // movl %r12d, %ecx + WORD $0xd929 // subl %ebx, %ecx + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0xff4e8966 // movw %cx, $-1(%rsi) + LONG $0xfec68348 // addq $-2, %rsi + LONG $0x0ffc8141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r12d + WORD $0x8941; BYTE $0xc4 // movl %eax, %r12d + LONG $0xffce870f; WORD $0xffff // ja LBB36_88, $-50(%rip) + +LBB36_89: + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x0016820f; WORD $0x0000 // jb LBB36_91, $22(%rip) + WORD $0xc089 // movl %eax, %eax + LONG $0x7c0d8d48; WORD $0x003a; BYTE $0x00 // leaq $14972(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x01894166 // movw %ax, (%r9) + LONG $0x000005e9; BYTE $0x00 // jmp LBB36_92, $5(%rip) + +LBB36_91: + WORD $0x3004 // addb $48, %al + WORD $0x8841; BYTE $0x01 // movb %al, (%r9) + +LBB36_92: + WORD $0x294d; BYTE $0xc7 // subq %r8, %r15 + WORD $0x294d; BYTE $0xc5 // subq %r8, %r13 + WORD $0xff49; BYTE $0xc5 // incq %r13 + LONG $0xd06d894c // movq %r13, $-48(%rbp) + LONG $0x18048d43 // leal (%r8,%r11), %eax + WORD $0xd8f6 // negb %al + LONG $0x03248d47 // leal (%r11,%r8), %r12d + WORD $0xf741; BYTE $0xdc // negl %r12d + LONG $0x032c8d47 // leal (%r11,%r8), %r13d + WORD $0xff41; BYTE $0xcd // decl %r13d + LONG $0x03348d43 // leal (%r11,%r8), %esi + WORD $0xc683; BYTE $0xfe // addl $-2, %esi + WORD $0xc931 // xorl %ecx, %ecx + + // .p2align 4, 0x90 +LBB36_93: + WORD $0xc389 // movl %eax, %ebx + WORD $0x438d; BYTE $0x03 // leal $3(%rbx), %eax + WORD $0xc6ff // incl %esi + LONG $0x0f7c8041; WORD $0x30ff // cmpb $48, $-1(%r15,%rcx) + LONG $0xff498d48 // leaq $-1(%rcx), %rcx + LONG $0xffe9840f; WORD $0xffff // je LBB36_93, $-23(%rip) + LONG $0x0f048d49 // leaq (%r15,%rcx), %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0xfdec8e0f; WORD $0xffff // jle LBB36_146, $-532(%rip) + WORD $0x2945; BYTE $0xc6 // subl %r8d, %r14d + LONG $0x0e148d41 // leal (%r14,%rcx), %edx + WORD $0xc2ff // incl %edx + WORD $0x3941; BYTE $0xd2 // cmpl %edx, %r10d + LONG $0x002b8d0f; WORD $0x0000 // jge LBB36_96, $43(%rip) + WORD $0x6349; BYTE $0xc4 // movslq %r12d, %rax + LONG $0x081c8d4c // leaq (%rax,%rcx), %r11 + WORD $0xff49; BYTE $0xc3 // incq %r11 + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x00ec8e0f; WORD $0x0000 // jle LBB36_114, $236(%rip) + WORD $0x8945; BYTE $0xd8 // movl %r11d, %r8d + LONG $0xff508d49 // leaq $-1(%r8), %rdx + LONG $0x03fa8348 // cmpq $3, %rdx + LONG $0x0073830f; WORD $0x0000 // jae LBB36_115, $115(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x000098e9; BYTE $0x00 // jmp LBB36_111, $152(%rip) + +LBB36_96: + WORD $0x8945; BYTE $0xea // movl %r13d, %r10d + WORD $0x2949; BYTE $0xca // subq %rcx, %r10 + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0xfda08e0f; WORD $0xffff // jle LBB36_146, $-608(%rip) + LONG $0x031c8d43 // leal (%r11,%r8), %ebx + WORD $0xc383; BYTE $0xfe // addl $-2, %ebx + WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx + WORD $0xd231 // xorl %edx, %edx + WORD $0xfb83; BYTE $0x1f // cmpl $31, %ebx + LONG $0x0198820f; WORD $0x0000 // jb LBB36_106, $408(%rip) + LONG $0x03348d47 // leal (%r11,%r8), %r14d + LONG $0xfec68341 // addl $-2, %r14d + WORD $0x2949; BYTE $0xce // subq %rcx, %r14 + WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d + WORD $0xff49; BYTE $0xc3 // incq %r11 + WORD $0x894c; BYTE $0xda // movq %r11, %rdx + LONG $0xe0e28348 // andq $-32, %rdx + LONG $0xd04d034c // addq $-48(%rbp), %r9 + WORD $0xf089 // movl %esi, %eax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xe0e08348 // andq $-32, %rax + WORD $0x014c; BYTE $0xc8 // addq %r9, %rax + LONG $0xe0728d48 // leaq $-32(%rdx), %rsi + WORD $0x8949; BYTE $0xf0 // movq %rsi, %r8 + LONG $0x05e8c149 // shrq $5, %r8 + WORD $0xff49; BYTE $0xc0 // incq %r8 + LONG $0x60fe8348 // cmpq $96, %rsi + LONG $0x0085830f; WORD $0x0000 // jae LBB36_100, $133(%rip) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0x0000e3e9; BYTE $0x00 // jmp LBB36_102, $227(%rip) + +LBB36_115: + LONG $0xfce38341 // andl $-4, %r11d + WORD $0xf749; BYTE $0xdb // negq %r11 + WORD $0xd231 // xorl %edx, %edx + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_116: + LONG $0x17048d49 // leaq (%r15,%rdx), %rax + LONG $0xfd01748b // movl $-3(%rcx,%rax), %esi + LONG $0xfe017489 // movl %esi, $-2(%rcx,%rax) + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 + LONG $0xffe7850f; WORD $0xffff // jne LBB36_116, $-25(%rip) + WORD $0xf748; BYTE $0xda // negq %rdx + +LBB36_111: + LONG $0x03c0f641 // testb $3, %r8b + LONG $0x0032840f; WORD $0x0000 // je LBB36_114, $50(%rip) + LONG $0xc3b60f44 // movzbl %bl, %r8d + LONG $0x03e08341 // andl $3, %r8d + WORD $0xf749; BYTE $0xd8 // negq %r8 + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi + WORD $0xd231 // xorl %edx, %edx + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB36_113: + LONG $0x161c8d48 // leaq (%rsi,%rdx), %rbx + LONG $0x1904b60f // movzbl (%rcx,%rbx), %eax + LONG $0x01194488 // movb %al, $1(%rcx,%rbx) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x3949; BYTE $0xd0 // cmpq %rdx, %r8 + LONG $0xffe8850f; WORD $0xffff // jne LBB36_113, $-24(%rip) + +LBB36_114: + WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax + LONG $0x0104c641; BYTE $0x2e // movb $46, (%r9,%rax) + LONG $0x0f048d49 // leaq (%r15,%rcx), %rax + LONG $0x02c08348 // addq $2, %rax + LONG $0xfffcc6e9; BYTE $0xff // jmp LBB36_146, $-826(%rip) + +LBB36_100: + WORD $0x8944; BYTE $0xf3 // movl %r14d, %ebx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xe0e38348 // andq $-32, %rbx + LONG $0xe0c38348 // addq $-32, %rbx + LONG $0x05ebc148 // shrq $5, %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfce38348 // andq $-4, %rbx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + QUAD $0xfffff3ff056f0f66 // movdqa $-3073(%rip), %xmm0 /* LCPI36_0(%rip) */ + +LBB36_101: + LONG $0x0f348d4b // leaq (%r15,%r9), %rsi + LONG $0x447f0ff3; WORD $0x0131 // movdqu %xmm0, $1(%rcx,%rsi) + LONG $0x447f0ff3; WORD $0x1131 // movdqu %xmm0, $17(%rcx,%rsi) + LONG $0x447f0ff3; WORD $0x2131 // movdqu %xmm0, $33(%rcx,%rsi) + LONG $0x447f0ff3; WORD $0x3131 // movdqu %xmm0, $49(%rcx,%rsi) + LONG $0x447f0ff3; WORD $0x4131 // movdqu %xmm0, $65(%rcx,%rsi) + LONG $0x447f0ff3; WORD $0x5131 // movdqu %xmm0, $81(%rcx,%rsi) + LONG $0x447f0ff3; WORD $0x6131 // movdqu %xmm0, $97(%rcx,%rsi) + LONG $0x447f0ff3; WORD $0x7131 // movdqu %xmm0, $113(%rcx,%rsi) + LONG $0x80e98349 // subq $-128, %r9 + LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xffbe850f; WORD $0xffff // jne LBB36_101, $-66(%rip) + +LBB36_102: + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0x03c0f641 // testb $3, %r8b + LONG $0x004b840f; WORD $0x0000 // je LBB36_105, $75(%rip) + WORD $0xfe41; BYTE $0xc6 // incb %r14b + LONG $0x60e68041 // andb $96, %r14b + LONG $0xe0c68041 // addb $-32, %r14b + LONG $0x05eec041 // shrb $5, %r14b + WORD $0xfe41; BYTE $0xc6 // incb %r14b + LONG $0xc6b60f45 // movzbl %r14b, %r8d + LONG $0x03e08341 // andl $3, %r8d + LONG $0x05e0c149 // shlq $5, %r8 + WORD $0x014d; BYTE $0xf9 // addq %r15, %r9 + LONG $0x11c18349 // addq $17, %r9 + WORD $0xdb31 // xorl %ebx, %ebx + QUAD $0xfffff381056f0f66 // movdqa $-3199(%rip), %xmm0 /* LCPI36_0(%rip) */ + +LBB36_104: + LONG $0x19348d49 // leaq (%r9,%rbx), %rsi + LONG $0x447f0ff3; WORD $0xf031 // movdqu %xmm0, $-16(%rcx,%rsi) + LONG $0x047f0ff3; BYTE $0x31 // movdqu %xmm0, (%rcx,%rsi) + LONG $0x20c38348 // addq $32, %rbx + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0xffe4850f; WORD $0xffff // jne LBB36_104, $-28(%rip) + +LBB36_105: + WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 + LONG $0xfbff840f; WORD $0xffff // je LBB36_146, $-1025(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB36_106: + WORD $0x00c6; BYTE $0x30 // movb $48, (%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0xc2ff // incl %edx + WORD $0x3944; BYTE $0xd2 // cmpl %r10d, %edx + LONG $0xffef8c0f; WORD $0xffff // jl LBB36_106, $-17(%rip) + LONG $0xfffbdde9; BYTE $0xff // jmp LBB36_146, $-1059(%rip) + +LBB36_1: + WORD $0xc031 // xorl %eax, %eax + LONG $0xfffbd8e9; BYTE $0xff // jmp LBB36_147, $-1064(%rip) + +LBB36_5: + LONG $0xff6bb841; WORD $0xffff // movl $-149, %r8d + WORD $0x8941; BYTE $0xc7 // movl %eax, %r15d + LONG $0xfff3b7e9; BYTE $0xff // jmp LBB36_6, $-3145(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +_format_significand: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0x20e8c148 // shrq $32, %rax + LONG $0x001c850f; WORD $0x0000 // jne LBB37_2, $28(%rip) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx + LONG $0x00e3830f; WORD $0x0000 // jae LBB37_8, $227(%rip) + +LBB37_7: + WORD $0xd789 // movl %edx, %edi + LONG $0x000132e9; BYTE $0x00 // jmp LBB37_10, $306(%rip) + +LBB37_2: + QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0xf748; BYTE $0xe1 // mulq %rcx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0x1f00ca69; WORD $0xfa0a // imull $-100000000, %edx, %ecx + WORD $0xf901 // addl %edi, %ecx + LONG $0x00a4840f; WORD $0x0000 // je LBB37_3, $164(%rip) + WORD $0xc889 // movl %ecx, %eax + LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d + LONG $0xc1af0f49 // imulq %r9, %rax + LONG $0x2de8c148 // shrq $45, %rax + LONG $0x2710f869; WORD $0x0000 // imull $10000, %eax, %edi + WORD $0xf929 // subl %edi, %ecx + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xf9af0f49 // imulq %r9, %rdi + LONG $0x2defc148 // shrq $45, %rdi + LONG $0x2710ff69; WORD $0x0000 // imull $10000, %edi, %edi + WORD $0xf829 // subl %edi, %eax + WORD $0xb70f; BYTE $0xf9 // movzwl %cx, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull $5243, %edi, %r9d + LONG $0x11e9c141 // shrl $17, %r9d + LONG $0x64f96b41 // imull $100, %r9d, %edi + WORD $0xf929 // subl %edi, %ecx + LONG $0xd1b70f44 // movzwl %cx, %r10d + WORD $0xb70f; BYTE $0xf8 // movzwl %ax, %edi + WORD $0xefc1; BYTE $0x02 // shrl $2, %edi + LONG $0x147bff69; WORD $0x0000 // imull $5243, %edi, %edi + WORD $0xefc1; BYTE $0x11 // shrl $17, %edi + WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0xd8b70f44 // movzwl %ax, %r11d + LONG $0x330d8d48; WORD $0x0037; BYTE $0x00 // leaq $14131(%rip), %rcx /* _Digits(%rip) */ + LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax + LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) + LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax + LONG $0x40894166; BYTE $0xfc // movw %ax, $-4(%r8) + LONG $0x04b70f42; BYTE $0x59 // movzwl (%rcx,%r11,2), %eax + LONG $0x40894166; BYTE $0xfa // movw %ax, $-6(%r8) + LONG $0x7904b70f // movzwl (%rcx,%rdi,2), %eax + LONG $0x40894166; BYTE $0xf8 // movw %ax, $-8(%r8) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0xf8708d4d // leaq $-8(%r8), %r14 + LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx + LONG $0xff38820f; WORD $0xffff // jb LBB37_7, $-200(%rip) + LONG $0x000016e9; BYTE $0x00 // jmp LBB37_8, $22(%rip) + +LBB37_3: + LONG $0x0008b941; WORD $0x0000 // movl $8, %r9d + LONG $0xf8708d4d // leaq $-8(%r8), %r14 + LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx + LONG $0xff1d820f; WORD $0xffff // jb LBB37_7, $-227(%rip) + +LBB37_8: + LONG $0x1759ba41; WORD $0xd1b7 // movl $3518437209, %r10d + LONG $0xd11d8d4c; WORD $0x0036; BYTE $0x00 // leaq $14033(%rip), %r11 /* _Digits(%rip) */ + BYTE $0x90 // .p2align 4, 0x90 + +LBB37_9: + WORD $0xd789 // movl %edx, %edi + LONG $0xfaaf0f49 // imulq %r10, %rdi + LONG $0x2defc148 // shrq $45, %rdi + LONG $0xd8f0c769; WORD $0xffff // imull $-10000, %edi, %eax + WORD $0xd001 // addl %edx, %eax + LONG $0x1fd86948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rbx + LONG $0x25ebc148 // shrq $37, %rbx + WORD $0xcb6b; BYTE $0x64 // imull $100, %ebx, %ecx + WORD $0xc829 // subl %ecx, %eax + LONG $0x04b70f41; BYTE $0x43 // movzwl (%r11,%rax,2), %eax + LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) + LONG $0x04b70f41; BYTE $0x5b // movzwl (%r11,%rbx,2), %eax + LONG $0x46894166; BYTE $0xfc // movw %ax, $-4(%r14) + LONG $0xfcc68349 // addq $-4, %r14 + LONG $0xe0fffa81; WORD $0x05f5 // cmpl $99999999, %edx + WORD $0xfa89 // movl %edi, %edx + LONG $0xffb8870f; WORD $0xffff // ja LBB37_9, $-72(%rip) + +LBB37_10: + WORD $0xff83; BYTE $0x64 // cmpl $100, %edi + LONG $0x0020830f; WORD $0x0000 // jae LBB37_11, $32(%rip) + WORD $0xff83; BYTE $0x0a // cmpl $10, %edi + LONG $0x004d820f; WORD $0x0000 // jb LBB37_14, $77(%rip) + +LBB37_13: + WORD $0xf889 // movl %edi, %eax + LONG $0x6d0d8d48; WORD $0x0036; BYTE $0x00 // leaq $13933(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) + LONG $0x00003de9; BYTE $0x00 // jmp LBB37_15, $61(%rip) + +LBB37_11: + WORD $0xb70f; BYTE $0xc7 // movzwl %di, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx + WORD $0xcf29 // subl %ecx, %edi + WORD $0xb70f; BYTE $0xcf // movzwl %di, %ecx + LONG $0x41158d48; WORD $0x0036; BYTE $0x00 // leaq $13889(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x4e894166; BYTE $0xfe // movw %cx, $-2(%r14) + LONG $0xfec68349 // addq $-2, %r14 + WORD $0xc789 // movl %eax, %edi + WORD $0xff83; BYTE $0x0a // cmpl $10, %edi + LONG $0xffb3830f; WORD $0xffff // jae LBB37_13, $-77(%rip) + +LBB37_14: + LONG $0x30c78040 // addb $48, %dil + WORD $0x8840; BYTE $0x3e // movb %dil, (%rsi) + +LBB37_15: + WORD $0x294d; BYTE $0xc8 // subq %r9, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +_left_shift: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + WORD $0xf189 // movl %esi, %ecx + LONG $0x68c16b48 // imulq $104, %rcx, %rax + LONG $0xea158d48; WORD $0x008f; BYTE $0x00 // leaq $36842(%rip), %rdx /* _LSHIFT_TAB(%rip) */ + LONG $0x10048b44 // movl (%rax,%rdx), %r8d + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0x04c28348 // addq $4, %rdx + LONG $0x10476348 // movslq $16(%rdi), %rax + WORD $0xf631 // xorl %esi, %esi + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0031840f; WORD $0x0000 // je LBB38_6, $49(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB38_1: + LONG $0x321cb60f // movzbl (%rdx,%rsi), %ebx + WORD $0xdb84 // testb %bl, %bl + LONG $0x0025840f; WORD $0x0000 // je LBB38_8, $37(%rip) + LONG $0x311c3841 // cmpb %bl, (%r9,%rsi) + LONG $0x0189850f; WORD $0x0000 // jne LBB38_3, $393(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffde850f; WORD $0xffff // jne LBB38_1, $-34(%rip) + WORD $0xc689 // movl %eax, %esi + +LBB38_6: + LONG $0x00323c80 // cmpb $0, (%rdx,%rsi) + LONG $0x0003840f; WORD $0x0000 // je LBB38_8, $3(%rip) + +LBB38_7: + WORD $0xff41; BYTE $0xc8 // decl %r8d + +LBB38_8: + WORD $0xc085 // testl %eax, %eax + LONG $0x00968e0f; WORD $0x0000 // jle LBB38_22, $150(%rip) + LONG $0x001c8d45 // leal (%r8,%rax), %r11d + WORD $0xc389 // movl %eax, %ebx + WORD $0x634d; BYTE $0xf3 // movslq %r11d, %r14 + WORD $0xff49; BYTE $0xce // decq %r14 + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xd231 // xorl %edx, %edx + QUAD $0xcccccccccccdba49; WORD $0xcccc // movabsq $-3689348814741910323, %r10 + LONG $0x000023e9; BYTE $0x00 // jmp LBB38_10, $35(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB38_11: + WORD $0x3004 // addb $48, %al + LONG $0x31048843 // movb %al, (%r9,%r14) + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + +LBB38_18: + WORD $0xff41; BYTE $0xcb // decl %r11d + WORD $0xff49; BYTE $0xce // decq %r14 + WORD $0xff48; BYTE $0xcb // decq %rbx + LONG $0x01fb8348 // cmpq $1, %rbx + LONG $0x0049860f; WORD $0x0000 // jbe LBB38_12, $73(%rip) + +LBB38_10: + WORD $0x438d; BYTE $0xfe // leal $-2(%rbx), %eax + LONG $0x34be0f49; BYTE $0x01 // movsbq (%r9,%rax), %rsi + LONG $0xd0c68348 // addq $-48, %rsi + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe2 // mulq %r10 + LONG $0x03eac148 // shrq $3, %rdx + LONG $0x12048d48 // leaq (%rdx,%rdx), %rax + LONG $0x803c8d4c // leaq (%rax,%rax,4), %r15 + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x294c; BYTE $0xf8 // subq %r15, %rax + LONG $0x0877394c // cmpq %r14, $8(%rdi) + LONG $0xffb0870f; WORD $0xffff // ja LBB38_11, $-80(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xffb0840f; WORD $0xffff // je LBB38_18, $-80(%rip) + LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) + LONG $0xffffa4e9; BYTE $0xff // jmp LBB38_18, $-92(%rip) + +LBB38_12: + LONG $0x0afe8348 // cmpq $10, %rsi + LONG $0x0070830f; WORD $0x0000 // jae LBB38_13, $112(%rip) + +LBB38_22: + LONG $0x10476348 // movslq $16(%rdi), %rax + WORD $0x6349; BYTE $0xc8 // movslq %r8d, %rcx + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) + LONG $0x08478b48 // movq $8(%rdi), %rax + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x0005870f; WORD $0x0000 // ja LBB38_24, $5(%rip) + WORD $0x4789; BYTE $0x10 // movl %eax, $16(%rdi) + WORD $0xc189 // movl %eax, %ecx + +LBB38_24: + LONG $0x14470144 // addl %r8d, $20(%rdi) + WORD $0xc985 // testl %ecx, %ecx + LONG $0x00318e0f; WORD $0x0000 // jle LBB38_28, $49(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0xc989 // movl %ecx, %ecx + BYTE $0x90 // .p2align 4, 0x90 + +LBB38_26: + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + WORD $0xd689 // movl %edx, %esi + LONG $0x30303c80 // cmpb $48, (%rax,%rsi) + LONG $0x0028850f; WORD $0x0000 // jne LBB38_30, $40(%rip) + WORD $0xc9ff // decl %ecx + WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) + LONG $0x01728d48 // leaq $1(%rdx), %rsi + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x01fe8348 // cmpq $1, %rsi + LONG $0xffda870f; WORD $0xffff // ja LBB38_26, $-38(%rip) + LONG $0x000006e9; BYTE $0x00 // jmp LBB38_29, $6(%rip) + +LBB38_28: + LONG $0x0007850f; WORD $0x0000 // jne LBB38_30, $7(%rip) + +LBB38_29: + LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) + +LBB38_30: + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB38_13: + WORD $0x6349; BYTE $0xf3 // movslq %r11d, %rsi + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x00001be9; BYTE $0x00 // jmp LBB38_14, $27(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB38_15: + WORD $0x3004 // addb $48, %al + WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx + WORD $0x0488; BYTE $0x33 // movb %al, (%rbx,%rsi) + +LBB38_21: + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x09f98348 // cmpq $9, %rcx + LONG $0xff6a860f; WORD $0xffff // jbe LBB38_22, $-150(%rip) + +LBB38_14: + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0xf749; BYTE $0xe2 // mulq %r10 + LONG $0x03eac148 // shrq $3, %rdx + LONG $0x12048d48 // leaq (%rdx,%rdx), %rax + LONG $0x801c8d48 // leaq (%rax,%rax,4), %rbx + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax + LONG $0x08773948 // cmpq %rsi, $8(%rdi) + LONG $0xffc6870f; WORD $0xffff // ja LBB38_15, $-58(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xffc5840f; WORD $0xffff // je LBB38_21, $-59(%rip) + LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) + LONG $0xffffb9e9; BYTE $0xff // jmp LBB38_21, $-71(%rip) + +LBB38_3: + LONG $0xfe898c0f; WORD $0xffff // jl LBB38_7, $-375(%rip) + LONG $0xfffe87e9; BYTE $0xff // jmp LBB38_8, $-377(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +_right_shift: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + WORD $0xf189 // movl %esi, %ecx + LONG $0x10478b44 // movl $16(%rdi), %r8d + WORD $0xd231 // xorl %edx, %edx + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0x0000bb41; WORD $0x0000 // movl $0, %r11d + LONG $0xd84f0f45 // cmovgl %r8d, %r11d + WORD $0xc031 // xorl %eax, %eax + LONG $0x90909090 // .p2align 4, 0x90 + +LBB39_1: + WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 + LONG $0x0132840f; WORD $0x0000 // je LBB39_2, $306(%rip) + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + LONG $0x34be0f48; BYTE $0x16 // movsbq (%rsi,%rdx), %rsi + LONG $0x46048d48 // leaq (%rsi,%rax,2), %rax + LONG $0xd0c08348 // addq $-48, %rax + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0xd348; BYTE $0xee // shrq %cl, %rsi + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xffd1840f; WORD $0xffff // je LBB39_1, $-47(%rip) + WORD $0x8941; BYTE $0xd3 // movl %edx, %r11d + +LBB39_7: + WORD $0x578b; BYTE $0x14 // movl $20(%rdi), %edx + WORD $0x2944; BYTE $0xda // subl %r11d, %edx + WORD $0xc2ff // incl %edx + LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 + WORD $0xd349; BYTE $0xe1 // shlq %cl, %r9 + WORD $0x5789; BYTE $0x14 // movl %edx, $20(%rdi) + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3945; BYTE $0xc3 // cmpl %r8d, %r11d + LONG $0x00718d0f; WORD $0x0000 // jge LBB39_10, $113(%rip) + WORD $0x634d; BYTE $0xc3 // movslq %r11d, %r8 + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + BYTE $0x90 // .p2align 4, 0x90 + +LBB39_9: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x214c; BYTE $0xc8 // andq %r9, %rax + WORD $0xc280; BYTE $0x30 // addb $48, %dl + LONG $0x16148842 // movb %dl, (%rsi,%r10) + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + LONG $0x06148d4a // leaq (%rsi,%r8), %rdx + LONG $0x1cbe0f4d; BYTE $0x12 // movsbq (%r10,%rdx), %r11 + LONG $0x105c8d4b; BYTE $0x01 // leaq $1(%r8,%r10), %rbx + WORD $0xff49; BYTE $0xc2 // incq %r10 + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + LONG $0x43048d49 // leaq (%r11,%rax,2), %rax + LONG $0xd0c08348 // addq $-48, %rax + LONG $0x10576348 // movslq $16(%rdi), %rdx + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0xffc38c0f; WORD $0xffff // jl LBB39_9, $-61(%rip) + LONG $0x000025e9; BYTE $0x00 // jmp LBB39_10, $37(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB39_12: + LONG $0x30c68040 // addb $48, %sil + WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx + LONG $0x13348840 // movb %sil, (%rbx,%rdx) + WORD $0xc2ff // incl %edx + WORD $0x8941; BYTE $0xd2 // movl %edx, %r10d + +LBB39_15: + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + +LBB39_10: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x002b840f; WORD $0x0000 // je LBB39_16, $43(%rip) + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0xd348; BYTE $0xee // shrq %cl, %rsi + WORD $0x214c; BYTE $0xc8 // andq %r9, %rax + WORD $0x6349; BYTE $0xd2 // movslq %r10d, %rdx + LONG $0x08573948 // cmpq %rdx, $8(%rdi) + LONG $0xffca870f; WORD $0xffff // ja LBB39_12, $-54(%rip) + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xffd1840f; WORD $0xffff // je LBB39_15, $-47(%rip) + LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) + LONG $0xffffc5e9; BYTE $0xff // jmp LBB39_15, $-59(%rip) + +LBB39_16: + LONG $0x10578944 // movl %r10d, $16(%rdi) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00758e0f; WORD $0x0000 // jle LBB39_20, $117(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0x9090 // .p2align 4, 0x90 + +LBB39_18: + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + WORD $0xd689 // movl %edx, %esi + LONG $0x30303c80 // cmpb $48, (%rax,%rsi) + LONG $0x0063850f; WORD $0x0000 // jne LBB39_22, $99(%rip) + WORD $0xc9ff // decl %ecx + WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) + LONG $0x01728d48 // leaq $1(%rdx), %rsi + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x01fe8348 // cmpq $1, %rsi + LONG $0xffda870f; WORD $0xffff // ja LBB39_18, $-38(%rip) + LONG $0x00004be9; BYTE $0x00 // jmp LBB39_21, $75(%rip) + +LBB39_2: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x004c840f; WORD $0x0000 // je LBB39_23, $76(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xfed3850f; WORD $0xffff // jne LBB39_7, $-301(%rip) + +LBB39_4: + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + WORD $0xff41; BYTE $0xc3 // incl %r11d + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xffe7840f; WORD $0xffff // je LBB39_4, $-25(%rip) + LONG $0xfffeb5e9; BYTE $0xff // jmp LBB39_7, $-331(%rip) + +LBB39_20: + LONG $0x0003840f; WORD $0x0000 // je LBB39_21, $3(%rip) + +LBB39_22: + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB39_21: + LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB39_23: + LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl $0, $16(%rdi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI40_0: + QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' + +LCPI40_1: + QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + + // .p2align 4, 0x90 +_advance_string_default: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + LONG $0x087f8b4c // movq $8(%rdi), %r15 + WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 + LONG $0x037d840f; WORD $0x0000 // je LBB40_17, $893(%rip) + WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + LONG $0x40ff8349 // cmpq $64, %r15 + LONG $0x01f7820f; WORD $0x0000 // jb LBB40_18, $503(%rip) + WORD $0x8948; BYTE $0xf7 // movq %rsi, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + QUAD $0xffffff98056f0f66 // movdqa $-104(%rip), %xmm0 /* LCPI40_0(%rip) */ + QUAD $0xffffffa00d6f0f66 // movdqa $-96(%rip), %xmm1 /* LCPI40_1(%rip) */ + + // .p2align 4, 0x90 +LBB40_3: + LONG $0x6f0f41f3; WORD $0x3114 // movdqu (%r9,%rsi), %xmm2 + LONG $0x6f0f41f3; WORD $0x315c; BYTE $0x10 // movdqu $16(%r9,%rsi), %xmm3 + LONG $0x6f0f41f3; WORD $0x3164; BYTE $0x20 // movdqu $32(%r9,%rsi), %xmm4 + LONG $0x6f0f41f3; WORD $0x316c; BYTE $0x30 // movdqu $48(%r9,%rsi), %xmm5 + LONG $0xf26f0f66 // movdqa %xmm2, %xmm6 + LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 + LONG $0xd70f4466; BYTE $0xe6 // pmovmskb %xmm6, %r12d + LONG $0xf36f0f66 // movdqa %xmm3, %xmm6 + LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 + LONG $0xded70f66 // pmovmskb %xmm6, %ebx + LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 + LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 + LONG $0xd70f4466; BYTE $0xc6 // pmovmskb %xmm6, %r8d + LONG $0xf56f0f66 // movdqa %xmm5, %xmm6 + LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 + LONG $0xd70f4466; BYTE $0xd6 // pmovmskb %xmm6, %r10d + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xd70f4466; BYTE $0xea // pmovmskb %xmm2, %r13d + LONG $0xd9740f66 // pcmpeqb %xmm1, %xmm3 + LONG $0xcbd70f66 // pmovmskb %xmm3, %ecx + LONG $0xe1740f66 // pcmpeqb %xmm1, %xmm4 + LONG $0xc4d70f66 // pmovmskb %xmm4, %eax + LONG $0xe9740f66 // pcmpeqb %xmm1, %xmm5 + LONG $0xd70f4466; BYTE $0xdd // pmovmskb %xmm5, %r11d + LONG $0x30e2c149 // shlq $48, %r10 + LONG $0x20e0c149 // shlq $32, %r8 + WORD $0x094d; BYTE $0xd0 // orq %r10, %r8 + LONG $0x10e3c148 // shlq $16, %rbx + WORD $0x094c; BYTE $0xc3 // orq %r8, %rbx + WORD $0x0949; BYTE $0xdc // orq %rbx, %r12 + LONG $0x30e3c149 // shlq $48, %r11 + LONG $0x20e0c148 // shlq $32, %rax + WORD $0x094c; BYTE $0xd8 // orq %r11, %rax + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + WORD $0x0949; BYTE $0xcd // orq %rcx, %r13 + LONG $0x0030850f; WORD $0x0000 // jne LBB40_7, $48(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0040850f; WORD $0x0000 // jne LBB40_9, $64(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0086850f; WORD $0x0000 // jne LBB40_10, $134(%rip) + +LBB40_6: + LONG $0xc0c78349 // addq $-64, %r15 + LONG $0xc0c78348 // addq $-64, %rdi + LONG $0x40c68348 // addq $64, %rsi + LONG $0x3fff8349 // cmpq $63, %r15 + LONG $0xff35870f; WORD $0xffff // ja LBB40_3, $-203(%rip) + LONG $0x000081e9; BYTE $0x00 // jmp LBB40_12, $129(%rip) + +LBB40_7: + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x000e850f; WORD $0x0000 // jne LBB40_9, $14(%rip) + LONG $0xc5bc0f49 // bsfq %r13, %rax + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0xd0458948 // movq %rax, $-48(%rbp) + WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) + +LBB40_9: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x214c; BYTE $0xe8 // andq %r13, %rax + LONG $0x00048d4c // leaq (%rax,%rax), %r8 + WORD $0x094d; BYTE $0xf0 // orq %r14, %r8 + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx + WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + LONG $0xc6920f41 // setb %r14b + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + QUAD $0x555555555555b848; WORD $0x5555 // movabsq $6148914691236517205, %rax + WORD $0x3148; BYTE $0xc1 // xorq %rax, %rcx + WORD $0x214c; BYTE $0xc1 // andq %r8, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x2149; BYTE $0xcc // andq %rcx, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0xff7a840f; WORD $0xffff // je LBB40_6, $-134(%rip) + +LBB40_10: + LONG $0xc4bc0f49 // bsfq %r12, %rax + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + +LBB40_11: + LONG $0x08c48348 // addq $8, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB40_12: + WORD $0x014c; BYTE $0xce // addq %r9, %rsi + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x00f5820f; WORD $0x0000 // jb LBB40_23, $245(%rip) + +LBB40_13: + LONG $0x066f0ff3 // movdqu (%rsi), %xmm0 + LONG $0x4e6f0ff3; BYTE $0x10 // movdqu $16(%rsi), %xmm1 + QUAD $0xfffffe21156f0f66 // movdqa $-479(%rip), %xmm2 /* LCPI40_0(%rip) */ + QUAD $0xfffffe291d6f0f66 // movdqa $-471(%rip), %xmm3 /* LCPI40_1(%rip) */ + LONG $0xe06f0f66 // movdqa %xmm0, %xmm4 + LONG $0xe2740f66 // pcmpeqb %xmm2, %xmm4 + LONG $0xfcd70f66 // pmovmskb %xmm4, %edi + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0xc3740f66 // pcmpeqb %xmm3, %xmm0 + LONG $0xc0d70f66 // pmovmskb %xmm0, %eax + LONG $0xcb740f66 // pcmpeqb %xmm3, %xmm1 + LONG $0xd9d70f66 // pmovmskb %xmm1, %ebx + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi + LONG $0x10e3c148 // shlq $16, %rbx + WORD $0x0948; BYTE $0xd8 // orq %rbx, %rax + LONG $0x0044850f; WORD $0x0000 // jne LBB40_19, $68(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x005a850f; WORD $0x0000 // jne LBB40_21, $90(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0087840f; WORD $0x0000 // je LBB40_22, $135(%rip) + +LBB40_16: + LONG $0xc7bc0f48 // bsfq %rdi, %rax + WORD $0x294c; BYTE $0xce // subq %r9, %rsi + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xffff6ce9; BYTE $0xff // jmp LBB40_11, $-148(%rip) + +LBB40_18: + WORD $0x014c; BYTE $0xce // addq %r9, %rsi + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0xff70830f; WORD $0xffff // jae LBB40_13, $-144(%rip) + LONG $0x000060e9; BYTE $0x00 // jmp LBB40_23, $96(%rip) + +LBB40_19: + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0014850f; WORD $0x0000 // jne LBB40_21, $20(%rip) + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + WORD $0x294c; BYTE $0xc9 // subq %r9, %rcx + LONG $0xd8bc0f48 // bsfq %rax, %rbx + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) + +LBB40_21: + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xc121 // andl %eax, %ecx + WORD $0x1c8d; BYTE $0x09 // leal (%rcx,%rcx), %ebx + LONG $0x4e048d45 // leal (%r14,%rcx,2), %r8d + WORD $0xd3f7 // notl %ebx + WORD $0xc321 // andl %eax, %ebx + LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0xcb01 // addl %ecx, %ebx + LONG $0xc6920f41 // setb %r14b + WORD $0xdb01 // addl %ebx, %ebx + LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx + WORD $0x2144; BYTE $0xc3 // andl %r8d, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xdf21 // andl %ebx, %edi + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xff79850f; WORD $0xffff // jne LBB40_16, $-135(%rip) + +LBB40_22: + LONG $0x20c68348 // addq $32, %rsi + LONG $0xe0c78349 // addq $-32, %r15 + +LBB40_23: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x00b4850f; WORD $0x0000 // jne LBB40_38, $180(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0088840f; WORD $0x0000 // je LBB40_35, $136(%rip) + +LBB40_25: + WORD $0x894c; BYTE $0xcf // movq %r9, %rdi + WORD $0xf748; BYTE $0xdf // negq %rdi + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + +LBB40_26: + WORD $0xdb31 // xorl %ebx, %ebx + +LBB40_27: + LONG $0x1e0cb60f // movzbl (%rsi,%rbx), %ecx + WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx + LONG $0x0066840f; WORD $0x0000 // je LBB40_34, $102(%rip) + WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx + LONG $0x0011840f; WORD $0x0000 // je LBB40_30, $17(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 + LONG $0xffde850f; WORD $0xffff // jne LBB40_27, $-34(%rip) + LONG $0x00005de9; BYTE $0x00 // jmp LBB40_36, $93(%rip) + +LBB40_30: + LONG $0xff4f8d49 // leaq $-1(%r15), %rcx + WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx + LONG $0xfe9a840f; WORD $0xffff // je LBB40_11, $-358(%rip) + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x000e850f; WORD $0x0000 // jne LBB40_33, $14(%rip) + LONG $0x370c8d48 // leaq (%rdi,%rsi), %rcx + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + +LBB40_33: + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + LONG $0x02c68348 // addq $2, %rsi + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx + LONG $0xfec18348 // addq $-2, %rcx + LONG $0xfec78349 // addq $-2, %r15 + WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + LONG $0xff90850f; WORD $0xffff // jne LBB40_26, $-112(%rip) + LONG $0xfffe5be9; BYTE $0xff // jmp LBB40_11, $-421(%rip) + +LBB40_34: + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + +LBB40_35: + WORD $0x294c; BYTE $0xce // subq %r9, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0xfffe4ae9; BYTE $0xff // jmp LBB40_11, $-438(%rip) + +LBB40_36: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0xfe3a850f; WORD $0xffff // jne LBB40_11, $-454(%rip) + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + LONG $0xffffdde9; BYTE $0xff // jmp LBB40_35, $-35(%rip) + +LBB40_38: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x002f840f; WORD $0x0000 // je LBB40_17, $47(%rip) + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0010850f; WORD $0x0000 // jne LBB40_41, $16(%rip) + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0xd0458948 // movq %rax, $-48(%rbp) + WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) + +LBB40_41: + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff49; BYTE $0xcf // decq %r15 + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xff22850f; WORD $0xffff // jne LBB40_25, $-222(%rip) + LONG $0xffffa5e9; BYTE $0xff // jmp LBB40_35, $-91(%rip) + +LBB40_17: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffdeee9; BYTE $0xff // jmp LBB40_11, $-530(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +_unescape: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x18ec8348 // subq $24, %rsp + WORD $0x8b4c; BYTE $0x2f // movq (%rdi), %r13 + WORD $0x294c; BYTE $0xee // subq %r13, %rsi + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x00d38e0f; WORD $0x0000 // jle LBB41_13, $211(%rip) + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0x01458d49 // leaq $1(%r13), %rax + LONG $0x4db60f41; BYTE $0x01 // movzbl $1(%r13), %ecx + LONG $0x43158d48; WORD $0x0077; BYTE $0x00 // leaq $30531(%rip), %rdx /* __UnquoteTab(%rip) */ + LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx + LONG $0x00fff981; WORD $0x0000 // cmpl $255, %ecx + LONG $0x0017840f; WORD $0x0000 // je LBB41_4, $23(%rip) + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0021850f; WORD $0x0000 // jne LBB41_6, $33(%rip) + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xfdc3c748; WORD $0xffff; BYTE $0xff // movq $-3, %rbx + LONG $0x000096e9; BYTE $0x00 // jmp LBB41_13, $150(%rip) + +LBB41_4: + LONG $0x03fe8348 // cmpq $3, %rsi + LONG $0x0019870f; WORD $0x0000 // ja LBB41_7, $25(%rip) + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0x000084e9; BYTE $0x00 // jmp LBB41_13, $132(%rip) + +LBB41_6: + WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) + LONG $0x02078349 // addq $2, (%r15) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0x000073e9; BYTE $0x00 // jmp LBB41_13, $115(%rip) + +LBB41_7: + LONG $0x024d8b41 // movl $2(%r13), %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xd0f7 // notl %eax + LONG $0xcfd0918d; WORD $0xcfcf // leal $-808464432(%rcx), %edx + LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax + WORD $0xd085 // testl %edx, %eax + LONG $0x004a850f; WORD $0x0000 // jne LBB41_11, $74(%rip) + LONG $0x1919918d; WORD $0x1919 // leal $421075225(%rcx), %edx + WORD $0xca09 // orl %ecx, %edx + LONG $0x8080c2f7; WORD $0x8080 // testl $-2139062144, %edx + LONG $0x0036850f; WORD $0x0000 // jne LBB41_11, $54(%rip) + WORD $0xca89 // movl %ecx, %edx + LONG $0x7f7fe281; WORD $0x7f7f // andl $2139062143, %edx + LONG $0xc0c0c0bf; BYTE $0xc0 // movl $-1061109568, %edi + WORD $0xd729 // subl %edx, %edi + LONG $0x46469a8d; WORD $0x4646 // leal $1179010630(%rdx), %ebx + WORD $0xc721 // andl %eax, %edi + WORD $0xdf85 // testl %ebx, %edi + LONG $0x0017850f; WORD $0x0000 // jne LBB41_11, $23(%rip) + LONG $0xe0e0e0bf; BYTE $0xe0 // movl $-522133280, %edi + WORD $0xd729 // subl %edx, %edi + LONG $0x3939c281; WORD $0x3939 // addl $960051513, %edx + WORD $0xf821 // andl %edi, %eax + WORD $0xd085 // testl %edx, %eax + LONG $0x0020840f; WORD $0x0000 // je LBB41_14, $32(%rip) + +LBB41_11: + LONG $0x02c58349 // addq $2, %r13 + WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) + +LBB41_12: + LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx + +LBB41_13: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0x18c48348 // addq $24, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB41_14: + WORD $0xc90f // bswapl %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx + WORD $0xc101 // addl %eax, %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xc809 // orl %ecx, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx + LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx + LONG $0xe0b60f44 // movzbl %al, %r12d + WORD $0x0941; BYTE $0xcc // orl %ecx, %r12d + LONG $0x06558d49 // leaq $6(%r13), %rdx + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + LONG $0x7ffc8341 // cmpl $127, %r12d + LONG $0x004c860f; WORD $0x0000 // jbe LBB41_18, $76(%rip) + LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d + LONG $0x004c860f; WORD $0x0000 // jbe LBB41_19, $76(%rip) + QUAD $0xffff200024bc8d41 // leal $-57344(%r12), %edi + LONG $0xf7ffff81; WORD $0xffff // cmpl $-2049, %edi + LONG $0x0055870f; WORD $0x0000 // ja LBB41_20, $85(%rip) + WORD $0xe9c1; BYTE $0x0c // shrl $12, %ecx + WORD $0xc980; BYTE $0xe0 // orb $-32, %cl + WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) + LONG $0x06ecc141 // shrl $6, %r12d + LONG $0x3fe48041 // andb $63, %r12b + LONG $0x80cc8041 // orb $-128, %r12b + LONG $0x01668845 // movb %r12b, $1(%r14) + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x02468841 // movb %al, $2(%r14) + LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx + LONG $0xffff5fe9; BYTE $0xff // jmp LBB41_13, $-161(%rip) + +LBB41_18: + WORD $0x8841; BYTE $0x06 // movb %al, (%r14) + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0xffff52e9; BYTE $0xff // jmp LBB41_13, $-174(%rip) + +LBB41_19: + LONG $0x06ecc141 // shrl $6, %r12d + LONG $0xc0cc8041 // orb $-64, %r12b + WORD $0x8845; BYTE $0x26 // movb %r12b, (%r14) + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x01468841 // movb %al, $1(%r14) + LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx + LONG $0xffff35e9; BYTE $0xff // jmp LBB41_13, $-203(%rip) + +LBB41_20: + LONG $0xfcc3c748; WORD $0xffff; BYTE $0xff // movq $-4, %rbx + LONG $0x06fe8348 // cmpq $6, %rsi + LONG $0xff24820f; WORD $0xffff // jb LBB41_13, $-220(%rip) + LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d + LONG $0xff17870f; WORD $0xffff // ja LBB41_13, $-233(%rip) + WORD $0x3a80; BYTE $0x5c // cmpb $92, (%rdx) + LONG $0xff0e850f; WORD $0xffff // jne LBB41_13, $-242(%rip) + LONG $0x077d8041; BYTE $0x75 // cmpb $117, $7(%r13) + LONG $0xff03850f; WORD $0xffff // jne LBB41_13, $-253(%rip) + LONG $0x08458d49 // leaq $8(%r13), %rax + LONG $0xc8458948 // movq %rax, $-56(%rbp) + LONG $0x087d8b41 // movl $8(%r13), %edi + WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) + LONG $0xff9c65e8; BYTE $0xff // callq _unhex16_is, $-25499(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x0050840f; WORD $0x0000 // je LBB41_27, $80(%rip) + WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx + WORD $0xca0f // bswapl %edx + WORD $0xd089 // movl %edx, %eax + WORD $0xd0f7 // notl %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe281; WORD $0x0f0f // andl $252645135, %edx + WORD $0xc201 // addl %eax, %edx + WORD $0xd189 // movl %edx, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xd109 // orl %edx, %ecx + WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax + WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx + LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx + WORD $0x148d; BYTE $0x01 // leal (%rcx,%rax), %edx + LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx + LONG $0xfbfffa81; WORD $0xffff // cmpl $-1025, %edx + LONG $0x0018870f; WORD $0x0000 // ja LBB41_28, $24(%rip) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xfffe97e9; BYTE $0xff // jmp LBB41_13, $-361(%rip) + +LBB41_27: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xfffe84e9; BYTE $0xff // jmp LBB41_12, $-380(%rip) + +LBB41_28: + WORD $0xc109 // orl %eax, %ecx + LONG $0x0ae4c141 // shll $10, %r12d + WORD $0xc889 // movl %ecx, %eax + WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax + WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx + LONG $0x2400c181; WORD $0xfca0 // addl $-56613888, %ecx + WORD $0xca89 // movl %ecx, %edx + WORD $0xeac1; BYTE $0x12 // shrl $18, %edx + WORD $0xca80; BYTE $0xf0 // orb $-16, %dl + WORD $0x8841; BYTE $0x16 // movb %dl, (%r14) + WORD $0xca89 // movl %ecx, %edx + WORD $0xeac1; BYTE $0x0c // shrl $12, %edx + WORD $0xe280; BYTE $0x3f // andb $63, %dl + WORD $0xca80; BYTE $0x80 // orb $-128, %dl + LONG $0x01568841 // movb %dl, $1(%r14) + WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + LONG $0x024e8841 // movb %cl, $2(%r14) + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + LONG $0x03468841 // movb %al, $3(%r14) + LONG $0x0cc58349 // addq $12, %r13 + WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) + LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx + LONG $0xfffe37e9; BYTE $0xff // jmp LBB41_13, $-457(%rip) + QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 + +_POW10_M128_TAB: + QUAD $0x1732c869cd60e453 // .quad 1671618768450675795 + QUAD $0xfa8fd5a0081c0288 // .quad -391859759250406776 + QUAD $0x0e7fbd42205c8eb4 // .quad 1044761730281672372 + QUAD $0x9c99e58405118195 // .quad -7162441377172586091 + QUAD $0x521fac92a873b261 // .quad 5917638181279478369 + QUAD $0xc3c05ee50655e1fa // .quad -4341365703038344710 + QUAD $0xe6a797b752909ef9 // .quad -1826324310255427847 + QUAD $0xf4b0769e47eb5a78 // .quad -815021110370542984 + QUAD $0x9028bed2939a635c // .quad -8058981721550724260 + QUAD $0x98ee4a22ecf3188b // .quad -7426917221622671221 + QUAD $0x7432ee873880fc33 // .quad 8373016921771146291 + QUAD $0xbf29dcaba82fdeae // .quad -4671960508600951122 + QUAD $0x113faa2906a13b3f // .quad 1242899115359157055 + QUAD $0xeef453d6923bd65a // .quad -1228264617323800998 + QUAD $0x4ac7ca59a424c507 // .quad 5388497965526861063 + QUAD $0x9558b4661b6565f8 // .quad -7685194413468457480 + QUAD $0x5d79bcf00d2df649 // .quad 6735622456908576329 + QUAD $0xbaaee17fa23ebf76 // .quad -4994806998408183946 + QUAD $0xf4d82c2c107973dc // .quad -803843965719055396 + QUAD $0xe95a99df8ace6f53 // .quad -1631822729582842029 + QUAD $0x79071b9b8a4be869 // .quad 8720969558280366185 + QUAD $0x91d8a02bb6c10594 // .quad -7937418233630358124 + QUAD $0x9748e2826cdee284 // .quad -7545532125859093884 + QUAD $0xb64ec836a47146f9 // .quad -5310086773610559751 + QUAD $0xfd1b1b2308169b25 // .quad -208543120469091547 + QUAD $0xe3e27a444d8d98b7 // .quad -2025922448585811785 + QUAD $0xfe30f0f5e50e20f7 // .quad -130339450293182217 + QUAD $0x8e6d8c6ab0787f72 // .quad -8183730558007214222 + QUAD $0xbdbd2d335e51a935 // .quad -4774610331293865675 + QUAD $0xb208ef855c969f4f // .quad -5617977179081629873 + QUAD $0xad2c788035e61382 // .quad -5968262914117332094 + QUAD $0xde8b2b66b3bc4723 // .quad -2410785455424649437 + QUAD $0x4c3bcb5021afcc31 // .quad 5493207715531443249 + QUAD $0x8b16fb203055ac76 // .quad -8424269937281487754 + QUAD $0xdf4abe242a1bbf3d // .quad -2356862392440471747 + QUAD $0xaddcb9e83c6b1793 // .quad -5918651403174471789 + QUAD $0xd71d6dad34a2af0d // .quad -2946077990550589683 + QUAD $0xd953e8624b85dd78 // .quad -2786628235540701832 + QUAD $0x8672648c40e5ad68 // .quad -8758827771735200408 + QUAD $0x87d4713d6f33aa6b // .quad -8659171674854020501 + QUAD $0x680efdaf511f18c2 // .quad 7498209359040551106 + QUAD $0xa9c98d8ccb009506 // .quad -6212278575140137722 + QUAD $0x0212bd1b2566def2 // .quad 149389661945913074 + QUAD $0xd43bf0effdc0ba48 // .quad -3153662200497784248 + QUAD $0x014bb630f7604b57 // .quad 93368538716195671 + QUAD $0x84a57695fe98746d // .quad -8888567902952197011 + QUAD $0x419ea3bd35385e2d // .quad 4728396691822632493 + QUAD $0xa5ced43b7e3e9188 // .quad -6499023860262858360 + QUAD $0x52064cac828675b9 // .quad 5910495864778290617 + QUAD $0xcf42894a5dce35ea // .quad -3512093806901185046 + QUAD $0x7343efebd1940993 // .quad 8305745933913819539 + QUAD $0x818995ce7aa0e1b2 // .quad -9112587656954322510 + QUAD $0x1014ebe6c5f90bf8 // .quad 1158810380537498616 + QUAD $0xa1ebfb4219491a1f // .quad -6779048552765515233 + QUAD $0xd41a26e077774ef6 // .quad -3163173042755514634 + QUAD $0xca66fa129f9b60a6 // .quad -3862124672529506138 + QUAD $0x8920b098955522b4 // .quad -8565652321871781196 + QUAD $0xfd00b897478238d0 // .quad -215969822234494768 + QUAD $0x55b46e5f5d5535b0 // .quad 6175682344898606512 + QUAD $0x9e20735e8cb16382 // .quad -7052510166537641086 + QUAD $0xeb2189f734aa831d // .quad -1503769105731517667 + QUAD $0xc5a890362fddbc62 // .quad -4203951689744663454 + QUAD $0xa5e9ec7501d523e4 // .quad -6491397400591784988 + QUAD $0xf712b443bbd52b7b // .quad -643253593753441413 + QUAD $0x47b233c92125366e // .quad 5166248661484910190 + QUAD $0x9a6bb0aa55653b2d // .quad -7319562523736982739 + QUAD $0x999ec0bb696e840a // .quad -7377247228426025974 + QUAD $0xc1069cd4eabe89f8 // .quad -4537767136243840520 + QUAD $0xc00670ea43ca250d // .quad -4609873017105144563 + QUAD $0xf148440a256e2c76 // .quad -1060522901877412746 + QUAD $0x380406926a5e5728 // .quad 4036358391950366504 + QUAD $0x96cd2a865764dbca // .quad -7580355841314464822 + QUAD $0xc605083704f5ecf2 // .quad -4177924046916817678 + QUAD $0xbc807527ed3e12bc // .quad -4863758783215693124 + QUAD $0xf7864a44c633682e // .quad -610719040218634194 + QUAD $0xeba09271e88d976b // .quad -1468012460592228501 + QUAD $0x7ab3ee6afbe0211d // .quad 8841672636718129437 + QUAD $0x93445b8731587ea3 // .quad -7835036815511224669 + QUAD $0x5960ea05bad82964 // .quad 6440404777470273892 + QUAD $0xb8157268fdae9e4c // .quad -5182110000961642932 + QUAD $0x6fb92487298e33bd // .quad 8050505971837842365 + QUAD $0xe61acf033d1a45df // .quad -1865951482774665761 + QUAD $0xa5d3b6d479f8e056 // .quad -6497648813669818282 + QUAD $0x8fd0c16206306bab // .quad -8083748704375247957 + QUAD $0x8f48a4899877186c // .quad -8122061017087272852 + QUAD $0xb3c4f1ba87bc8696 // .quad -5492999862041672042 + QUAD $0x331acdabfe94de87 // .quad 3682481783923072647 + QUAD $0xe0b62e2929aba83c // .quad -2254563809124702148 + QUAD $0x9ff0c08b7f1d0b14 // .quad -6921820921902855404 + QUAD $0x8c71dcd9ba0b4925 // .quad -8326631408344020699 + QUAD $0x07ecf0ae5ee44dd9 // .quad 571095884476206553 + QUAD $0xaf8e5410288e1b6f // .quad -5796603242002637969 + QUAD $0xc9e82cd9f69d6150 // .quad -3897816162832129712 + QUAD $0xdb71e91432b1a24a // .quad -2634068034075909558 + QUAD $0xbe311c083a225cd2 // .quad -4741978110983775022 + QUAD $0x892731ac9faf056e // .quad -8563821548938525330 + QUAD $0x6dbd630a48aaf406 // .quad 7907585416552444934 + QUAD $0xab70fe17c79ac6ca // .quad -6093090917745768758 + QUAD $0x092cbbccdad5b108 // .quad 661109733835780360 + QUAD $0xd64d3d9db981787d // .quad -3004677628754823043 + QUAD $0x25bbf56008c58ea5 // .quad 2719036592861056677 + QUAD $0x85f0468293f0eb4e // .quad -8795452545612846258 + QUAD $0xaf2af2b80af6f24e // .quad -5824576295778454962 + QUAD $0xa76c582338ed2621 // .quad -6382629663588669919 + QUAD $0x1af5af660db4aee1 // .quad 1942651667131707105 + QUAD $0xd1476e2c07286faa // .quad -3366601061058449494 + QUAD $0x50d98d9fc890ed4d // .quad 5825843310384704845 + QUAD $0x82cca4db847945ca // .quad -9021654690802612790 + QUAD $0xe50ff107bab528a0 // .quad -1941067898873894752 + QUAD $0xa37fce126597973c // .quad -6665382345075878084 + QUAD $0x1e53ed49a96272c8 // .quad 2185351144835019464 + QUAD $0xcc5fc196fefd7d0c // .quad -3720041912917459700 + QUAD $0x25e8e89c13bb0f7a // .quad 2731688931043774330 + QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721 + QUAD $0x77b191618c54e9ac // .quad 8624834609543440812 + QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807 + QUAD $0xd59df5b9ef6a2417 // .quad -3054014793352862697 + QUAD $0xc795830d75038c1d // .quad -4065198994811024355 + QUAD $0x4b0573286b44ad1d // .quad 5405853545163697437 + QUAD $0xf97ae3d0d2446f25 // .quad -469812725086392539 + QUAD $0x4ee367f9430aec32 // .quad 5684501474941004850 + QUAD $0x9becce62836ac577 // .quad -7211161980820077193 + QUAD $0x229c41f793cda73f // .quad 2493940825248868159 + QUAD $0xc2e801fb244576d5 // .quad -4402266457597708587 + QUAD $0x6b43527578c1110f // .quad 7729112049988473103 + QUAD $0xf3a20279ed56d48a // .quad -891147053569747830 + QUAD $0x830a13896b78aaa9 // .quad -9004363024039368023 + QUAD $0x9845418c345644d6 // .quad -7474495936122174250 + QUAD $0x23cc986bc656d553 // .quad 2579604275232953683 + QUAD $0xbe5691ef416bd60c // .quad -4731433901725329908 + QUAD $0x2cbfbe86b7ec8aa8 // .quad 3224505344041192104 + QUAD $0xedec366b11c6cb8f // .quad -1302606358729274481 + QUAD $0x7bf7d71432f3d6a9 // .quad 8932844867666826921 + QUAD $0x94b3a202eb1c3f39 // .quad -7731658001846878407 + QUAD $0xdaf5ccd93fb0cc53 // .quad -2669001970698630061 + QUAD $0xb9e08a83a5e34f07 // .quad -5052886483881210105 + QUAD $0xd1b3400f8f9cff68 // .quad -3336252463373287576 + QUAD $0xe858ad248f5c22c9 // .quad -1704422086424124727 + QUAD $0x23100809b9c21fa1 // .quad 2526528228819083169 + QUAD $0x91376c36d99995be // .quad -7982792831656159810 + QUAD $0xabd40a0c2832a78a // .quad -6065211750830921846 + QUAD $0xb58547448ffffb2d // .quad -5366805021142811859 + QUAD $0x16c90c8f323f516c // .quad 1641857348316123500 + QUAD $0xe2e69915b3fff9f9 // .quad -2096820258001126919 + QUAD $0xae3da7d97f6792e3 // .quad -5891368184943504669 + QUAD $0x8dd01fad907ffc3b // .quad -8228041688891786181 + QUAD $0x99cd11cfdf41779c // .quad -7364210231179380836 + QUAD $0xb1442798f49ffb4a // .quad -5673366092687344822 + QUAD $0x40405643d711d583 // .quad 4629795266307937667 + QUAD $0xdd95317f31c7fa1d // .quad -2480021597431793123 + QUAD $0x482835ea666b2572 // .quad 5199465050656154994 + QUAD $0x8a7d3eef7f1cfc52 // .quad -8467542526035952558 + QUAD $0xda3243650005eecf // .quad -2724040723534582065 + QUAD $0xad1c8eab5ee43b66 // .quad -5972742139117552794 + QUAD $0x90bed43e40076a82 // .quad -8016736922845615486 + QUAD $0xd863b256369d4a40 // .quad -2854241655469553088 + QUAD $0x5a7744a6e804a291 // .quad 6518754469289960081 + QUAD $0x873e4f75e2224e68 // .quad -8701430062309552536 + QUAD $0x711515d0a205cb36 // .quad 8148443086612450102 + QUAD $0xa90de3535aaae202 // .quad -6265101559459552766 + QUAD $0x0d5a5b44ca873e03 // .quad 962181821410786819 + QUAD $0xd3515c2831559a83 // .quad -3219690930897053053 + QUAD $0xe858790afe9486c2 // .quad -1704479370831952190 + QUAD $0x8412d9991ed58091 // .quad -8929835859451740015 + QUAD $0x626e974dbe39a872 // .quad 7092772823314835570 + QUAD $0xa5178fff668ae0b6 // .quad -6550608805887287114 + QUAD $0xfb0a3d212dc8128f // .quad -357406007711231345 + QUAD $0xce5d73ff402d98e3 // .quad -3576574988931720989 + QUAD $0x7ce66634bc9d0b99 // .quad 8999993282035256217 + QUAD $0x80fa687f881c7f8e // .quad -9152888395723407474 + QUAD $0x1c1fffc1ebc44e80 // .quad 2026619565689294464 + QUAD $0xa139029f6a239f72 // .quad -6829424476226871438 + QUAD $0xa327ffb266b56220 // .quad -6690097579743157728 + QUAD $0xc987434744ac874e // .quad -3925094576856201394 + QUAD $0x4bf1ff9f0062baa8 // .quad 5472436080603216552 + QUAD $0xfbe9141915d7a922 // .quad -294682202642863838 + QUAD $0x6f773fc3603db4a9 // .quad 8031958568804398249 + QUAD $0x9d71ac8fada6c9b5 // .quad -7101705404292871755 + QUAD $0xcb550fb4384d21d3 // .quad -3795109844276665901 + QUAD $0xc4ce17b399107c22 // .quad -4265445736938701790 + QUAD $0x7e2a53a146606a48 // .quad 9091170749936331336 + QUAD $0xf6019da07f549b2b // .quad -720121152745989333 + QUAD $0x2eda7444cbfc426d // .quad 3376138709496513133 + QUAD $0x99c102844f94e0fb // .quad -7367604748107325189 + QUAD $0xfa911155fefb5308 // .quad -391512631556746488 + QUAD $0xc0314325637a1939 // .quad -4597819916706768583 + QUAD $0x793555ab7eba27ca // .quad 8733981247408842698 + QUAD $0xf03d93eebc589f88 // .quad -1135588877456072824 + QUAD $0x4bc1558b2f3458de // .quad 5458738279630526686 + QUAD $0x96267c7535b763b5 // .quad -7627272076051127371 + QUAD $0x9eb1aaedfb016f16 // .quad -7011635205744005354 + QUAD $0xbbb01b9283253ca2 // .quad -4922404076636521310 + QUAD $0x465e15a979c1cadc // .quad 5070514048102157020 + QUAD $0xea9c227723ee8bcb // .quad -1541319077368263733 + QUAD $0x0bfacd89ec191ec9 // .quad 863228270850154185 + QUAD $0x92a1958a7675175f // .quad -7880853450996246689 + QUAD $0xcef980ec671f667b // .quad -3532650679864695173 + QUAD $0xb749faed14125d36 // .quad -5239380795317920458 + QUAD $0x82b7e12780e7401a // .quad -9027499368258256870 + QUAD $0xe51c79a85916f484 // .quad -1937539975720012668 + QUAD $0xd1b2ecb8b0908810 // .quad -3336344095947716592 + QUAD $0x8f31cc0937ae58d2 // .quad -8128491512466089774 + QUAD $0x861fa7e6dcb4aa15 // .quad -8782116138362033643 + QUAD $0xb2fe3f0b8599ef07 // .quad -5548928372155224313 + QUAD $0x67a791e093e1d49a // .quad 7469098900757009562 + QUAD $0xdfbdcece67006ac9 // .quad -2324474446766642487 + QUAD $0xe0c8bb2c5c6d24e0 // .quad -2249342214667950880 + QUAD $0x8bd6a141006042bd // .quad -8370325556870233411 + QUAD $0x58fae9f773886e18 // .quad 6411694268519837208 + QUAD $0xaecc49914078536d // .quad -5851220927660403859 + QUAD $0xaf39a475506a899e // .quad -5820440219632367202 + QUAD $0xda7f5bf590966848 // .quad -2702340141148116920 + QUAD $0x6d8406c952429603 // .quad 7891439908798240259 + QUAD $0x888f99797a5e012d // .quad -8606491615858654931 + QUAD $0xc8e5087ba6d33b83 // .quad -3970758169284363389 + QUAD $0xaab37fd7d8f58178 // .quad -6146428501395930760 + QUAD $0xfb1e4a9a90880a64 // .quad -351761693178066332 + QUAD $0xd5605fcdcf32e1d6 // .quad -3071349608317525546 + QUAD $0x5cf2eea09a55067f // .quad 6697677969404790399 + QUAD $0x855c3be0a17fcd26 // .quad -8837122532839535322 + QUAD $0xf42faa48c0ea481e // .quad -851274575098787810 + QUAD $0xa6b34ad8c9dfc06f // .quad -6434717147622031249 + QUAD $0xf13b94daf124da26 // .quad -1064093218873484762 + QUAD $0xd0601d8efc57b08b // .quad -3431710416100151157 + QUAD $0x76c53d08d6b70858 // .quad 8558313775058847832 + QUAD $0x823c12795db6ce57 // .quad -9062348037703676329 + QUAD $0x54768c4b0c64ca6e // .quad 6086206200396171886 + QUAD $0xa2cb1717b52481ed // .quad -6716249028702207507 + QUAD $0xa9942f5dcf7dfd09 // .quad -6227300304786948855 + QUAD $0xcb7ddcdda26da268 // .quad -3783625267450371480 + QUAD $0xd3f93b35435d7c4c // .quad -3172439362556298164 + QUAD $0xfe5d54150b090b02 // .quad -117845565885576446 + QUAD $0xc47bc5014a1a6daf // .quad -4288617610811380305 + QUAD $0x9efa548d26e5a6e1 // .quad -6991182506319567135 + QUAD $0x359ab6419ca1091b // .quad 3862600023340550427 + QUAD $0xc6b8e9b0709f109a // .quad -4127292114472071014 + QUAD $0xc30163d203c94b62 // .quad -4395122007679087774 + QUAD $0xf867241c8cc6d4c0 // .quad -547429124662700864 + QUAD $0x79e0de63425dcf1d // .quad 8782263791269039901 + QUAD $0x9b407691d7fc44f8 // .quad -7259672230555269896 + QUAD $0x985915fc12f542e4 // .quad -7468914334623251740 + QUAD $0xc21094364dfb5636 // .quad -4462904269766699466 + QUAD $0x3e6f5b7b17b2939d // .quad 4498915137003099037 + QUAD $0xf294b943e17a2bc4 // .quad -966944318780986428 + QUAD $0xa705992ceecf9c42 // .quad -6411550076227838910 + QUAD $0x979cf3ca6cec5b5a // .quad -7521869226879198374 + QUAD $0x50c6ff782a838353 // .quad 5820620459997365075 + QUAD $0xbd8430bd08277231 // .quad -4790650515171610063 + QUAD $0xa4f8bf5635246428 // .quad -6559282480285457368 + QUAD $0xece53cec4a314ebd // .quad -1376627125537124675 + QUAD $0x871b7795e136be99 // .quad -8711237568605798759 + QUAD $0x940f4613ae5ed136 // .quad -7777920981101784778 + QUAD $0x28e2557b59846e3f // .quad 2946011094524915263 + QUAD $0xb913179899f68584 // .quad -5110715207949843068 + QUAD $0x331aeada2fe589cf // .quad 3682513868156144079 + QUAD $0xe757dd7ec07426e5 // .quad -1776707991509915931 + QUAD $0x3ff0d2c85def7621 // .quad 4607414176811284001 + QUAD $0x9096ea6f3848984f // .quad -8027971522334779313 + QUAD $0x0fed077a756b53a9 // .quad 1147581702586717097 + QUAD $0xb4bca50b065abe63 // .quad -5423278384491086237 + QUAD $0xd3e8495912c62894 // .quad -3177208890193991532 + QUAD $0xe1ebce4dc7f16dfb // .quad -2167411962186469893 + QUAD $0x64712dd7abbbd95c // .quad 7237616480483531100 + QUAD $0x8d3360f09cf6e4bd // .quad -8272161504007625539 + QUAD $0xbd8d794d96aacfb3 // .quad -4788037454677749837 + QUAD $0xb080392cc4349dec // .quad -5728515861582144020 + QUAD $0xecf0d7a0fc5583a0 // .quad -1373360799919799392 + QUAD $0xdca04777f541c567 // .quad -2548958808550292121 + QUAD $0xf41686c49db57244 // .quad -858350499949874620 + QUAD $0x89e42caaf9491b60 // .quad -8510628282985014432 + QUAD $0x311c2875c522ced5 // .quad 3538747893490044629 + QUAD $0xac5d37d5b79b6239 // .quad -6026599335303880135 + QUAD $0x7d633293366b828b // .quad 9035120885289943691 + QUAD $0xd77485cb25823ac7 // .quad -2921563150702462265 + QUAD $0xae5dff9c02033197 // .quad -5882264492762254953 + QUAD $0x86a8d39ef77164bc // .quad -8743505996830120772 + QUAD $0xd9f57f830283fdfc // .quad -2741144597525430788 + QUAD $0xa8530886b54dbdeb // .quad -6317696477610263061 + QUAD $0xd072df63c324fd7b // .quad -3426430746906788485 + QUAD $0xd267caa862a12d66 // .quad -3285434578585440922 + QUAD $0x4247cb9e59f71e6d // .quad 4776009810824339053 + QUAD $0x8380dea93da4bc60 // .quad -8970925639256982432 + QUAD $0x52d9be85f074e608 // .quad 5970012263530423816 + QUAD $0xa46116538d0deb78 // .quad -6601971030643840136 + QUAD $0x67902e276c921f8b // .quad 7462515329413029771 + QUAD $0xcd795be870516656 // .quad -3640777769877412266 + QUAD $0x00ba1cd8a3db53b6 // .quad 52386062455755702 + QUAD $0x806bd9714632dff6 // .quad -9193015133814464522 + QUAD $0x80e8a40eccd228a4 // .quad -9157889458785081180 + QUAD $0xa086cfcd97bf97f3 // .quad -6879582898840692749 + QUAD $0x6122cd128006b2cd // .quad 6999382250228200141 + QUAD $0xc8a883c0fdaf7df0 // .quad -3987792605123478032 + QUAD $0x796b805720085f81 // .quad 8749227812785250177 + QUAD $0xfad2a4b13d1b5d6c // .quad -373054737976959636 + QUAD $0xcbe3303674053bb0 // .quad -3755104653863994448 + QUAD $0x9cc3a6eec6311a63 // .quad -7150688238876681629 + QUAD $0xbedbfc4411068a9c // .quad -4693880817329993060 + QUAD $0xc3f490aa77bd60fc // .quad -4326674280168464132 + QUAD $0xee92fb5515482d44 // .quad -1255665003235103420 + QUAD $0xf4f1b4d515acb93b // .quad -796656831783192261 + QUAD $0x751bdd152d4d1c4a // .quad 8438581409832836170 + QUAD $0x991711052d8bf3c5 // .quad -7415439547505577019 + QUAD $0xd262d45a78a0635d // .quad -3286831292991118499 + QUAD $0xbf5cd54678eef0b6 // .quad -4657613415954583370 + QUAD $0x86fb897116c87c34 // .quad -8720225134666286028 + QUAD $0xef340a98172aace4 // .quad -1210330751515841308 + QUAD $0xd45d35e6ae3d4da0 // .quad -3144297699952734816 + QUAD $0x9580869f0e7aac0e // .quad -7673985747338482674 + QUAD $0x8974836059cca109 // .quad -8542058143368306423 + QUAD $0xbae0a846d2195712 // .quad -4980796165745715438 + QUAD $0x2bd1a438703fc94b // .quad 3157485376071780683 + QUAD $0xe998d258869facd7 // .quad -1614309188754756393 + QUAD $0x7b6306a34627ddcf // .quad 8890957387685944783 + QUAD $0x91ff83775423cc06 // .quad -7926472270612804602 + QUAD $0x1a3bc84c17b1d542 // .quad 1890324697752655170 + QUAD $0xb67f6455292cbf08 // .quad -5296404319838617848 + QUAD $0x20caba5f1d9e4a93 // .quad 2362905872190818963 + QUAD $0xe41f3d6a7377eeca // .quad -2008819381370884406 + QUAD $0x547eb47b7282ee9c // .quad 6088502188546649756 + QUAD $0x8e938662882af53e // .quad -8173041140997884610 + QUAD $0xe99e619a4f23aa43 // .quad -1612744301171463613 + QUAD $0xb23867fb2a35b28d // .quad -5604615407819967859 + QUAD $0x6405fa00e2ec94d4 // .quad 7207441660390446292 + QUAD $0xdec681f9f4c31f31 // .quad -2394083241347571919 + QUAD $0xde83bc408dd3dd04 // .quad -2412877989897052924 + QUAD $0x8b3c113c38f9f37e // .quad -8413831053483314306 + QUAD $0x9624ab50b148d445 // .quad -7627783505798704059 + QUAD $0xae0b158b4738705e // .quad -5905602798426754978 + QUAD $0x3badd624dd9b0957 // .quad 4300328673033783639 + QUAD $0xd98ddaee19068c76 // .quad -2770317479606055818 + QUAD $0xe54ca5d70a80e5d6 // .quad -1923980597781273130 + QUAD $0x87f8a8d4cfa417c9 // .quad -8648977452394866743 + QUAD $0x5e9fcf4ccd211f4c // .quad 6818396289628184396 + QUAD $0xa9f6d30a038d1dbc // .quad -6199535797066195524 + QUAD $0x7647c3200069671f // .quad 8522995362035230495 + QUAD $0xd47487cc8470652b // .quad -3137733727905356501 + QUAD $0x29ecd9f40041e073 // .quad 3021029092058325107 + QUAD $0x84c8d4dfd2c63f3b // .quad -8878612607581929669 + QUAD $0xf468107100525890 // .quad -835399653354481520 + QUAD $0xa5fb0a17c777cf09 // .quad -6486579741050024183 + QUAD $0x7182148d4066eeb4 // .quad 8179122470161673908 + QUAD $0xcf79cc9db955c2cc // .quad -3496538657885142324 + QUAD $0xc6f14cd848405530 // .quad -4111420493003729616 + QUAD $0x81ac1fe293d599bf // .quad -9102865688819295809 + QUAD $0xb8ada00e5a506a7c // .quad -5139275616254662020 + QUAD $0xa21727db38cb002f // .quad -6766896092596731857 + QUAD $0xa6d90811f0e4851c // .quad -6424094520318327524 + QUAD $0xca9cf1d206fdc03b // .quad -3846934097318526917 + QUAD $0x908f4a166d1da663 // .quad -8030118150397909405 + QUAD $0xfd442e4688bd304a // .quad -196981603220770742 + QUAD $0x9a598e4e043287fe // .quad -7324666853212387330 + QUAD $0x9e4a9cec15763e2e // .quad -7040642529654063570 + QUAD $0x40eff1e1853f29fd // .quad 4679224488766679549 + QUAD $0xc5dd44271ad3cdba // .quad -4189117143640191558 + QUAD $0xd12bee59e68ef47c // .quad -3374341425896426372 + QUAD $0xf7549530e188c128 // .quad -624710411122851544 + QUAD $0x82bb74f8301958ce // .quad -9026492418826348338 + QUAD $0x9a94dd3e8cf578b9 // .quad -7307973034592864071 + QUAD $0xe36a52363c1faf01 // .quad -2059743486678159615 + QUAD $0xc13a148e3032d6e7 // .quad -4523280274813692185 + QUAD $0xdc44e6c3cb279ac1 // .quad -2574679358347699519 + QUAD $0xf18899b1bc3f8ca1 // .quad -1042414325089727327 + QUAD $0x29ab103a5ef8c0b9 // .quad 3002511419460075705 + QUAD $0x96f5600f15a7b7e5 // .quad -7569037980822161435 + QUAD $0x7415d448f6b6f0e7 // .quad 8364825292752482535 + QUAD $0xbcb2b812db11a5de // .quad -4849611457600313890 + QUAD $0x111b495b3464ad21 // .quad 1232659579085827361 + QUAD $0xebdf661791d60f56 // .quad -1450328303573004458 + QUAD $0xcab10dd900beec34 // .quad -3841273781498745804 + QUAD $0x936b9fcebb25c995 // .quad -7823984217374209643 + QUAD $0x3d5d514f40eea742 // .quad 4421779809981343554 + QUAD $0xb84687c269ef3bfb // .quad -5168294253290374149 + QUAD $0x0cb4a5a3112a5112 // .quad 915538744049291538 + QUAD $0xe65829b3046b0afa // .quad -1848681798185579782 + QUAD $0x47f0e785eaba72ab // .quad 5183897733458195115 + QUAD $0x8ff71a0fe2c2e6dc // .quad -8072955151507069220 + QUAD $0x59ed216765690f56 // .quad 6479872166822743894 + QUAD $0xb3f4e093db73a093 // .quad -5479507920956448621 + QUAD $0x306869c13ec3532c // .quad 3488154190101041964 + QUAD $0xe0f218b8d25088b8 // .quad -2237698882768172872 + QUAD $0x1e414218c73a13fb // .quad 2180096368813151227 + QUAD $0x8c974f7383725573 // .quad -8316090829371189901 + QUAD $0xe5d1929ef90898fa // .quad -1886565557410948870 + QUAD $0xafbd2350644eeacf // .quad -5783427518286599473 + QUAD $0xdf45f746b74abf39 // .quad -2358206946763686087 + QUAD $0xdbac6c247d62a583 // .quad -2617598379430861437 + QUAD $0x6b8bba8c328eb783 // .quad 7749492695127472003 + QUAD $0x894bc396ce5da772 // .quad -8553528014785370254 + QUAD $0x066ea92f3f326564 // .quad 463493832054564196 + QUAD $0xab9eb47c81f5114f // .quad -6080224000054324913 + QUAD $0xc80a537b0efefebd // .quad -4032318728359182659 + QUAD $0xd686619ba27255a2 // .quad -2988593981640518238 + QUAD $0xbd06742ce95f5f36 // .quad -4826042214438183114 + QUAD $0x8613fd0145877585 // .quad -8785400266166405755 + QUAD $0x2c48113823b73704 // .quad 3190819268807046916 + QUAD $0xa798fc4196e952e7 // .quad -6370064314280619289 + QUAD $0xf75a15862ca504c5 // .quad -623161932418579259 + QUAD $0xd17f3b51fca3a7a0 // .quad -3350894374423386208 + QUAD $0x9a984d73dbe722fb // .quad -7307005235402693893 + QUAD $0x82ef85133de648c4 // .quad -9011838011655698236 + QUAD $0xc13e60d0d2e0ebba // .quad -4522070525825979462 + QUAD $0xa3ab66580d5fdaf5 // .quad -6653111496142234891 + QUAD $0x318df905079926a8 // .quad 3570783879572301480 + QUAD $0xcc963fee10b7d1b3 // .quad -3704703351750405709 + QUAD $0xfdf17746497f7052 // .quad -148206168962011054 + QUAD $0xffbbcfe994e5c61f // .quad -19193171260619233 + QUAD $0xfeb6ea8bedefa633 // .quad -92628855601256909 + QUAD $0x9fd561f1fd0f9bd3 // .quad -6929524759678968877 + QUAD $0xfe64a52ee96b8fc0 // .quad -115786069501571136 + QUAD $0xc7caba6e7c5382c8 // .quad -4050219931171323192 + QUAD $0x3dfdce7aa3c673b0 // .quad 4466953431550423984 + QUAD $0xf9bd690a1b68637b // .quad -451088895536766085 + QUAD $0x06bea10ca65c084e // .quad 486002885505321038 + QUAD $0x9c1661a651213e2d // .quad -7199459587351560659 + QUAD $0x486e494fcff30a62 // .quad 5219189625309039202 + QUAD $0xc31bfa0fe5698db8 // .quad -4387638465762062920 + QUAD $0x5a89dba3c3efccfa // .quad 6523987031636299002 + QUAD $0xf3e2f893dec3f126 // .quad -872862063775190746 + QUAD $0xf89629465a75e01c // .quad -534194123654701028 + QUAD $0x986ddb5c6b3a76b7 // .quad -7463067817500576073 + QUAD $0xf6bbb397f1135823 // .quad -667742654568376285 + QUAD $0xbe89523386091465 // .quad -4717148753448332187 + QUAD $0x746aa07ded582e2c // .quad 8388693718644305452 + QUAD $0xee2ba6c0678b597f // .quad -1284749923383027329 + QUAD $0xa8c2a44eb4571cdc // .quad -6286281471915778852 + QUAD $0x94db483840b717ef // .quad -7720497729755473937 + QUAD $0x92f34d62616ce413 // .quad -7857851839894723565 + QUAD $0xba121a4650e4ddeb // .quad -5038936143766954517 + QUAD $0x77b020baf9c81d17 // .quad 8624429273841147159 + QUAD $0xe896a0d7e51e1566 // .quad -1686984161281305242 + QUAD $0x0ace1474dc1d122e // .quad 778582277723329070 + QUAD $0x915e2486ef32cd60 // .quad -7971894128441897632 + QUAD $0x0d819992132456ba // .quad 973227847154161338 + QUAD $0xb5b5ada8aaff80b8 // .quad -5353181642124984136 + QUAD $0x10e1fff697ed6c69 // .quad 1216534808942701673 + QUAD $0xe3231912d5bf60e6 // .quad -2079791034228842266 + QUAD $0xca8d3ffa1ef463c1 // .quad -3851351762838199359 + QUAD $0x8df5efabc5979c8f // .quad -8217398424034108273 + QUAD $0xbd308ff8a6b17cb2 // .quad -4814189703547749198 + QUAD $0xb1736b96b6fd83b3 // .quad -5660062011615247437 + QUAD $0xac7cb3f6d05ddbde // .quad -6017737129434686498 + QUAD $0xddd0467c64bce4a0 // .quad -2463391496091671392 + QUAD $0x6bcdf07a423aa96b // .quad 7768129340171790699 + QUAD $0x8aa22c0dbef60ee4 // .quad -8457148712698376476 + QUAD $0x86c16c98d2c953c6 // .quad -8736582398494813242 + QUAD $0xad4ab7112eb3929d // .quad -5959749872445582691 + QUAD $0xe871c7bf077ba8b7 // .quad -1697355961263740745 + QUAD $0xd89d64d57a607744 // .quad -2838001322129590460 + QUAD $0x11471cd764ad4972 // .quad 1244995533423855986 + QUAD $0x87625f056c7c4a8b // .quad -8691279853972075893 + QUAD $0xd598e40d3dd89bcf // .quad -3055441601647567921 + QUAD $0xa93af6c6c79b5d2d // .quad -6252413799037706963 + QUAD $0x4aff1d108d4ec2c3 // .quad 5404070034795315907 + QUAD $0xd389b47879823479 // .quad -3203831230369745799 + QUAD $0xcedf722a585139ba // .quad -3539985255894009414 + QUAD $0x843610cb4bf160cb // .quad -8919923546622172981 + QUAD $0xc2974eb4ee658828 // .quad -4424981569867511768 + QUAD $0xa54394fe1eedb8fe // .quad -6538218414850328322 + QUAD $0x733d226229feea32 // .quad 8303831092947774002 + QUAD $0xce947a3da6a9273e // .quad -3561087000135522498 + QUAD $0x0806357d5a3f525f // .quad 578208414664970847 + QUAD $0x811ccc668829b887 // .quad -9143208402725783417 + QUAD $0xca07c2dcb0cf26f7 // .quad -3888925500096174345 + QUAD $0xa163ff802a3426a8 // .quad -6817324484979841368 + QUAD $0xfc89b393dd02f0b5 // .quad -249470856692830027 + QUAD $0xc9bcff6034c13052 // .quad -3909969587797413806 + QUAD $0xbbac2078d443ace2 // .quad -4923524589293425438 + QUAD $0xfc2c3f3841f17c67 // .quad -275775966319379353 + QUAD $0xd54b944b84aa4c0d // .quad -3077202868308390899 + QUAD $0x9d9ba7832936edc0 // .quad -7089889006590693952 + QUAD $0x0a9e795e65d4df11 // .quad 765182433041899281 + QUAD $0xc5029163f384a931 // .quad -4250675239810979535 + QUAD $0x4d4617b5ff4a16d5 // .quad 5568164059729762005 + QUAD $0xf64335bcf065d37d // .quad -701658031336336515 + QUAD $0x504bced1bf8e4e45 // .quad 5785945546544795205 + QUAD $0x99ea0196163fa42e // .quad -7356065297226292178 + QUAD $0xe45ec2862f71e1d6 // .quad -1990940103673781802 + QUAD $0xc06481fb9bcf8d39 // .quad -4583395603105477319 + QUAD $0x5d767327bb4e5a4c // .quad 6734696907262548556 + QUAD $0xf07da27a82c37088 // .quad -1117558485454458744 + QUAD $0x3a6a07f8d510f86f // .quad 4209185567039092847 + QUAD $0x964e858c91ba2655 // .quad -7616003081050118571 + QUAD $0x890489f70a55368b // .quad -8573576096483297653 + QUAD $0xbbe226efb628afea // .quad -4908317832885260310 + QUAD $0x2b45ac74ccea842e // .quad 3118087934678041646 + QUAD $0xeadab0aba3b2dbe5 // .quad -1523711272679187483 + QUAD $0x3b0b8bc90012929d // .quad 4254647968387469981 + QUAD $0x92c8ae6b464fc96f // .quad -7869848573065574033 + QUAD $0x09ce6ebb40173744 // .quad 706623942056949572 + QUAD $0xb77ada0617e3bbcb // .quad -5225624697904579637 + QUAD $0xcc420a6a101d0515 // .quad -3728406090856200939 + QUAD $0xe55990879ddcaabd // .quad -1920344853953336643 + QUAD $0x9fa946824a12232d // .quad -6941939825212513491 + QUAD $0x8f57fa54c2a9eab6 // .quad -8117744561361917258 + QUAD $0x47939822dc96abf9 // .quad 5157633273766521849 + QUAD $0xb32df8e9f3546564 // .quad -5535494683275008668 + QUAD $0x59787e2b93bc56f7 // .quad 6447041592208152311 + QUAD $0xdff9772470297ebd // .quad -2307682335666372931 + QUAD $0x57eb4edb3c55b65a // .quad 6335244004343789146 + QUAD $0x8bfbea76c619ef36 // .quad -8359830487432564938 + QUAD $0xede622920b6b23f1 // .quad -1304317031425039375 + QUAD $0xaefae51477a06b03 // .quad -5838102090863318269 + QUAD $0xe95fab368e45eced // .quad -1630396289281299219 + QUAD $0xdab99e59958885c4 // .quad -2685941595151759932 + QUAD $0x11dbcb0218ebb414 // .quad 1286845328412881940 + QUAD $0x88b402f7fd75539b // .quad -8596242524610931813 + QUAD $0xd652bdc29f26a119 // .quad -3003129357911285479 + QUAD $0xaae103b5fcd2a881 // .quad -6133617137336276863 + QUAD $0x4be76d3346f0495f // .quad 5469460339465668959 + QUAD $0xd59944a37c0752a2 // .quad -3055335403242958174 + QUAD $0x6f70a4400c562ddb // .quad 8030098730593431003 + QUAD $0x857fcae62d8493a5 // .quad -8827113654667930715 + QUAD $0xcb4ccd500f6bb952 // .quad -3797434642040374958 + QUAD $0xa6dfbd9fb8e5b88e // .quad -6422206049907525490 + QUAD $0x7e2000a41346a7a7 // .quad 9088264752731695015 + QUAD $0xd097ad07a71f26b2 // .quad -3416071543957018958 + QUAD $0x8ed400668c0c28c8 // .quad -8154892584824854328 + QUAD $0x825ecc24c873782f // .quad -9052573742614218705 + QUAD $0x728900802f0f32fa // .quad 8253128342678483706 + QUAD $0xa2f67f2dfa90563b // .quad -6704031159840385477 + QUAD $0x4f2b40a03ad2ffb9 // .quad 5704724409920716729 + QUAD $0xcbb41ef979346bca // .quad -3768352931373093942 + QUAD $0xe2f610c84987bfa8 // .quad -2092466524453879896 + QUAD $0xfea126b7d78186bc // .quad -98755145788979524 + QUAD $0x0dd9ca7d2df4d7c9 // .quad 998051431430019017 + QUAD $0x9f24b832e6b0f436 // .quad -6979250993759194058 + QUAD $0x91503d1c79720dbb // .quad -7975807747567252037 + QUAD $0xc6ede63fa05d3143 // .quad -4112377723771604669 + QUAD $0x75a44c6397ce912a // .quad 8476984389250486570 + QUAD $0xf8a95fcf88747d94 // .quad -528786136287117932 + QUAD $0xc986afbe3ee11aba // .quad -3925256793573221702 + QUAD $0x9b69dbe1b548ce7c // .quad -7248020362820530564 + QUAD $0xfbe85badce996168 // .quad -294884973539139224 + QUAD $0xc24452da229b021b // .quad -4448339435098275301 + QUAD $0xfae27299423fb9c3 // .quad -368606216923924029 + QUAD $0xf2d56790ab41c2a2 // .quad -948738275445456222 + QUAD $0xdccd879fc967d41a // .quad -2536221894791146470 + QUAD $0x97c560ba6b0919a5 // .quad -7510490449794491995 + QUAD $0x5400e987bbc1c920 // .quad 6053094668365842720 + QUAD $0xbdb6b8e905cb600f // .quad -4776427043815727089 + QUAD $0x290123e9aab23b68 // .quad 2954682317029915496 + QUAD $0xed246723473e3813 // .quad -1358847786342270957 + QUAD $0xf9a0b6720aaf6521 // .quad -459166561069996767 + QUAD $0x9436c0760c86e30b // .quad -7766808894105001205 + QUAD $0xf808e40e8d5b3e69 // .quad -573958201337495959 + QUAD $0xb94470938fa89bce // .quad -5096825099203863602 + QUAD $0xb60b1d1230b20e04 // .quad -5329133770099257852 + QUAD $0xe7958cb87392c2c2 // .quad -1759345355577441598 + QUAD $0xb1c6f22b5e6f48c2 // .quad -5636551615525730110 + QUAD $0x90bd77f3483bb9b9 // .quad -8017119874876982855 + QUAD $0x1e38aeb6360b1af3 // .quad 2177682517447613171 + QUAD $0xb4ecd5f01a4aa828 // .quad -5409713825168840664 + QUAD $0x25c6da63c38de1b0 // .quad 2722103146809516464 + QUAD $0xe2280b6c20dd5232 // .quad -2150456263033662926 + QUAD $0x579c487e5a38ad0e // .quad 6313000485183335694 + QUAD $0x8d590723948a535f // .quad -8261564192037121185 + QUAD $0x2d835a9df0c6d851 // .quad 3279564588051781713 + QUAD $0xb0af48ec79ace837 // .quad -5715269221619013577 + QUAD $0xf8e431456cf88e65 // .quad -512230283362660763 + QUAD $0xdcdb1b2798182244 // .quad -2532400508596379068 + QUAD $0x1b8e9ecb641b58ff // .quad 1985699082112030975 + QUAD $0x8a08f0f8bf0f156b // .quad -8500279345513818773 + QUAD $0xe272467e3d222f3f // .quad -2129562165787349185 + QUAD $0xac8b2d36eed2dac5 // .quad -6013663163464885563 + QUAD $0x5b0ed81dcc6abb0f // .quad 6561419329620589327 + QUAD $0xd7adf884aa879177 // .quad -2905392935903719049 + QUAD $0x98e947129fc2b4e9 // .quad -7428327965055601431 + QUAD $0x86ccbb52ea94baea // .quad -8733399612580906262 + QUAD $0x3f2398d747b36224 // .quad 4549648098962661924 + QUAD $0xa87fea27a539e9a5 // .quad -6305063497298744923 + QUAD $0x8eec7f0d19a03aad // .quad -8147997931578836307 + QUAD $0xd29fe4b18e88640e // .quad -3269643353196043250 + QUAD $0x1953cf68300424ac // .quad 1825030320404309164 + QUAD $0x83a3eeeef9153e89 // .quad -8961056123388608887 + QUAD $0x5fa8c3423c052dd7 // .quad 6892973918932774359 + QUAD $0xa48ceaaab75a8e2b // .quad -6589634135808373205 + QUAD $0x3792f412cb06794d // .quad 4004531380238580045 + QUAD $0xcdb02555653131b6 // .quad -3625356651333078602 + QUAD $0xe2bbd88bbee40bd0 // .quad -2108853905778275376 + QUAD $0x808e17555f3ebf11 // .quad -9183376934724255983 + QUAD $0x5b6aceaeae9d0ec4 // .quad 6587304654631931588 + QUAD $0xa0b19d2ab70e6ed6 // .quad -6867535149977932074 + QUAD $0xf245825a5a445275 // .quad -989241218564861323 + QUAD $0xc8de047564d20a8b // .quad -3972732919045027189 + QUAD $0xeed6e2f0f0d56712 // .quad -1236551523206076654 + QUAD $0xfb158592be068d2e // .quad -354230130378896082 + QUAD $0x55464dd69685606b // .quad 6144684325637283947 + QUAD $0x9ced737bb6c4183d // .quad -7138922859127891907 + QUAD $0xaa97e14c3c26b886 // .quad -6154202648235558778 + QUAD $0xc428d05aa4751e4c // .quad -4311967555482476980 + QUAD $0xd53dd99f4b3066a8 // .quad -3081067291867060568 + QUAD $0xf53304714d9265df // .quad -778273425925708321 + QUAD $0xe546a8038efe4029 // .quad -1925667057416912855 + QUAD $0x993fe2c6d07b7fab // .quad -7403949918844649557 + QUAD $0xde98520472bdd033 // .quad -2407083821771141069 + QUAD $0xbf8fdb78849a5f96 // .quad -4643251380128424042 + QUAD $0x963e66858f6d4440 // .quad -7620540795641314240 + QUAD $0xef73d256a5c0f77c // .quad -1192378206733142148 + QUAD $0xdde7001379a44aa8 // .quad -2456994988062127448 + QUAD $0x95a8637627989aad // .quad -7662765406849295699 + QUAD $0x5560c018580d5d52 // .quad 6152128301777116498 + QUAD $0xbb127c53b17ec159 // .quad -4966770740134231719 + QUAD $0xaab8f01e6e10b4a6 // .quad -6144897678060768090 + QUAD $0xe9d71b689dde71af // .quad -1596777406740401745 + QUAD $0xcab3961304ca70e8 // .quad -3840561048787980056 + QUAD $0x9226712162ab070d // .quad -7915514906853832947 + QUAD $0x3d607b97c5fd0d22 // .quad 4422670725869800738 + QUAD $0xb6b00d69bb55c8d1 // .quad -5282707615139903279 + QUAD $0x8cb89a7db77c506a // .quad -8306719647944912790 + QUAD $0xe45c10c42a2b3b05 // .quad -1991698500497491195 + QUAD $0x77f3608e92adb242 // .quad 8643358275316593218 + QUAD $0x8eb98a7a9a5b04e3 // .quad -8162340590452013853 + QUAD $0x55f038b237591ed3 // .quad 6192511825718353619 + QUAD $0xb267ed1940f1c61c // .quad -5591239719637629412 + QUAD $0x6b6c46dec52f6688 // .quad 7740639782147942024 + QUAD $0xdf01e85f912e37a3 // .quad -2377363631119648861 + QUAD $0x2323ac4b3b3da015 // .quad 2532056854628769813 + QUAD $0x8b61313bbabce2c6 // .quad -8403381297090862394 + QUAD $0xabec975e0a0d081a // .quad -6058300968568813542 + QUAD $0xae397d8aa96c1b77 // .quad -5892540602936190089 + QUAD $0x96e7bd358c904a21 // .quad -7572876210711016927 + QUAD $0xd9c7dced53c72255 // .quad -2753989735242849707 + QUAD $0x7e50d64177da2e54 // .quad 9102010423587778132 + QUAD $0x881cea14545c7575 // .quad -8638772612167862923 + QUAD $0xdde50bd1d5d0b9e9 // .quad -2457545025797441047 + QUAD $0xaa242499697392d2 // .quad -6186779746782440750 + QUAD $0x955e4ec64b44e864 // .quad -7683617300674189212 + QUAD $0xd4ad2dbfc3d07787 // .quad -3121788665050663033 + QUAD $0xbd5af13bef0b113e // .quad -4802260812921368258 + QUAD $0x84ec3c97da624ab4 // .quad -8868646943297746252 + QUAD $0xecb1ad8aeacdd58e // .quad -1391139997724322418 + QUAD $0xa6274bbdd0fadd61 // .quad -6474122660694794911 + QUAD $0x67de18eda5814af2 // .quad 7484447039699372786 + QUAD $0xcfb11ead453994ba // .quad -3480967307441105734 + QUAD $0x80eacf948770ced7 // .quad -9157278655470055721 + QUAD $0x81ceb32c4b43fcf4 // .quad -9093133594791772940 + QUAD $0xa1258379a94d028d // .quad -6834912300910181747 + QUAD $0xa2425ff75e14fc31 // .quad -6754730975062328271 + QUAD $0x096ee45813a04330 // .quad 679731660717048624 + QUAD $0xcad2f7f5359a3b3e // .quad -3831727700400522434 + QUAD $0x8bca9d6e188853fc // .quad -8373707460958465028 + QUAD $0xfd87b5f28300ca0d // .quad -177973607073265139 + QUAD $0x775ea264cf55347d // .quad 8601490892183123069 + QUAD $0x9e74d1b791e07e48 // .quad -7028762532061872568 + QUAD $0x95364afe032a819d // .quad -7694880458480647779 + QUAD $0xc612062576589dda // .quad -4174267146649952806 + QUAD $0x3a83ddbd83f52204 // .quad 4216457482181353988 + QUAD $0xf79687aed3eec551 // .quad -606147914885053103 + QUAD $0xc4926a9672793542 // .quad -4282243101277735614 + QUAD $0x9abe14cd44753b52 // .quad -7296371474444240046 + QUAD $0x75b7053c0f178293 // .quad 8482254178684994195 + QUAD $0xc16d9a0095928a27 // .quad -4508778324627912153 + QUAD $0x5324c68b12dd6338 // .quad 5991131704928854840 + QUAD $0xf1c90080baf72cb1 // .quad -1024286887357502287 + QUAD $0xd3f6fc16ebca5e03 // .quad -3173071712060547581 + QUAD $0x971da05074da7bee // .quad -7557708332239520786 + QUAD $0x88f4bb1ca6bcf584 // .quad -8578025658503072380 + QUAD $0xbce5086492111aea // .quad -4835449396872013078 + QUAD $0x2b31e9e3d06c32e5 // .quad 3112525982153323237 + QUAD $0xec1e4a7db69561a5 // .quad -1432625727662628443 + QUAD $0x3aff322e62439fcf // .quad 4251171748059520975 + QUAD $0x9392ee8e921d5d07 // .quad -7812920107430224633 + QUAD $0x09befeb9fad487c2 // .quad 702278666647013314 + QUAD $0xb877aa3236a4b449 // .quad -5154464115860392887 + QUAD $0x4c2ebe687989a9b3 // .quad 5489534351736154547 + QUAD $0xe69594bec44de15b // .quad -1831394126398103205 + QUAD $0x0f9d37014bf60a10 // .quad 1125115960621402640 + QUAD $0x901d7cf73ab0acd9 // .quad -8062150356639896359 + QUAD $0x538484c19ef38c94 // .quad 6018080969204141204 + QUAD $0xb424dc35095cd80f // .quad -5466001927372482545 + QUAD $0x2865a5f206b06fb9 // .quad 2910915193077788601 + QUAD $0xe12e13424bb40e13 // .quad -2220816390788215277 + QUAD $0xf93f87b7442e45d3 // .quad -486521013540076077 + QUAD $0x8cbccc096f5088cb // .quad -8305539271883716405 + QUAD $0xf78f69a51539d748 // .quad -608151266925095096 + QUAD $0xafebff0bcb24aafe // .quad -5770238071427257602 + QUAD $0xb573440e5a884d1b // .quad -5371875102083756773 + QUAD $0xdbe6fecebdedd5be // .quad -2601111570856684098 + QUAD $0x31680a88f8953030 // .quad 3560107088838733872 + QUAD $0x89705f4136b4a597 // .quad -8543223759426509417 + QUAD $0xfdc20d2b36ba7c3d // .quad -161552157378970563 + QUAD $0xabcc77118461cefc // .quad -6067343680855748868 + QUAD $0x3d32907604691b4c // .quad 4409745821703674700 + QUAD $0xd6bf94d5e57a42bc // .quad -2972493582642298180 + QUAD $0xa63f9a49c2c1b10f // .quad -6467280898289979121 + QUAD $0x8637bd05af6c69b5 // .quad -8775337516792518219 + QUAD $0x0fcf80dc33721d53 // .quad 1139270913992301907 + QUAD $0xa7c5ac471b478423 // .quad -6357485877563259869 + QUAD $0xd3c36113404ea4a8 // .quad -3187597375937010520 + QUAD $0xd1b71758e219652b // .quad -3335171328526686933 + QUAD $0x645a1cac083126e9 // .quad 7231123676894144233 + QUAD $0x83126e978d4fdf3b // .quad -9002011107970261189 + QUAD $0x3d70a3d70a3d70a3 // .quad 4427218577690292387 + QUAD $0xa3d70a3d70a3d70a // .quad -6640827866535438582 + QUAD $0xcccccccccccccccc; QUAD $0xcccccccccccccccc // .space 16, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc' + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8000000000000000 // .quad -9223372036854775808 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa000000000000000 // .quad -6917529027641081856 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc800000000000000 // .quad -4035225266123964416 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xfa00000000000000 // .quad -432345564227567616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9c40000000000000 // .quad -7187745005283311616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc350000000000000 // .quad -4372995238176751616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xf424000000000000 // .quad -854558029293551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9896800000000000 // .quad -7451627795949551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xbebc200000000000 // .quad -4702848726509551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xee6b280000000000 // .quad -1266874889709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9502f90000000000 // .quad -7709325833709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xba43b74000000000 // .quad -5024971273709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe8d4a51000000000 // .quad -1669528073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9184e72a00000000 // .quad -7960984073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb5e620f480000000 // .quad -5339544073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe35fa931a0000000 // .quad -2062744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8ac7230489e80000 // .quad -8446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x878678326eac9000 // .quad -8681119073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa968163f0a57b400 // .quad -6239712823709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x84595161401484a0 // .quad -8910000909647051616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366 + QUAD $0x4000000000000000 // .quad 4611686018427387904 + QUAD $0x813f3978f8940984 // .quad -9133518327554766460 + QUAD $0x5000000000000000 // .quad 5764607523034234880 + QUAD $0xa18f07d736b90be5 // .quad -6805211891016070171 + QUAD $0xa400000000000000 // .quad -6629298651489370112 + QUAD $0xc9f2c9cd04674ede // .quad -3894828845342699810 + QUAD $0x4d00000000000000 // .quad 5548434740920451072 + QUAD $0xfc6f7c4045812296 // .quad -256850038250986858 + QUAD $0xf020000000000000 // .quad -1143914305352105984 + QUAD $0x9dc5ada82b70b59d // .quad -7078060301547948643 + QUAD $0x6c28000000000000 // .quad 7793479155164643328 + QUAD $0xc5371912364ce305 // .quad -4235889358507547899 + QUAD $0xc732000000000000 // .quad -4093209111326359552 + QUAD $0xf684df56c3e01bc6 // .quad -683175679707046970 + QUAD $0x3c7f400000000000 // .quad 4359273333062107136 + QUAD $0x9a130b963a6c115c // .quad -7344513827457986212 + QUAD $0x4b9f100000000000 // .quad 5449091666327633920 + QUAD $0xc097ce7bc90715b3 // .quad -4568956265895094861 + QUAD $0x1e86d40000000000 // .quad 2199678564482154496 + QUAD $0xf0bdc21abb48db20 // .quad -1099509313941480672 + QUAD $0x1314448000000000 // .quad 1374799102801346560 + QUAD $0x96769950b50d88f4 // .quad -7604722348854507276 + QUAD $0x17d955a000000000 // .quad 1718498878501683200 + QUAD $0xbc143fa4e250eb31 // .quad -4894216917640746191 + QUAD $0x5dcfab0800000000 // .quad 6759809616554491904 + QUAD $0xeb194f8e1ae525fd // .quad -1506085128623544835 + QUAD $0x5aa1cae500000000 // .quad 6530724019560251392 + QUAD $0x92efd1b8d0cf37be // .quad -7858832233030797378 + QUAD $0xf14a3d9e40000000 // .quad -1059967012404461568 + QUAD $0xb7abc627050305ad // .quad -5211854272861108819 + QUAD $0x6d9ccd05d0000000 // .quad 7898413271349198848 + QUAD $0xe596b7b0c643c719 // .quad -1903131822648998119 + QUAD $0xe4820023a2000000 // .quad -1981020733047832576 + QUAD $0x8f7e32ce7bea5c6f // .quad -8106986416796705681 + QUAD $0xdda2802c8a800000 // .quad -2476275916309790720 + QUAD $0xb35dbf821ae4f38b // .quad -5522047002568494197 + QUAD $0xd50b2037ad200000 // .quad -3095344895387238400 + QUAD $0xe0352f62a19e306e // .quad -2290872734783229842 + QUAD $0x4526f422cc340000 // .quad 4982938468024057856 + QUAD $0x8c213d9da502de45 // .quad -8349324486880600507 + QUAD $0x9670b12b7f410000 // .quad -7606384970252091392 + QUAD $0xaf298d050e4395d6 // .quad -5824969590173362730 + QUAD $0x3c0cdd765f114000 // .quad 4327076842467049472 + QUAD $0xdaf3f04651d47b4c // .quad -2669525969289315508 + QUAD $0xa5880a69fb6ac800 // .quad -6518949010312869888 + QUAD $0x88d8762bf324cd0f // .quad -8585982758446904049 + QUAD $0x8eea0d047a457a00 // .quad -8148686262891087360 + QUAD $0xab0e93b6efee0053 // .quad -6120792429631242157 + QUAD $0x72a4904598d6d880 // .quad 8260886245095692416 + QUAD $0xd5d238a4abe98068 // .quad -3039304518611664792 + QUAD $0x47a6da2b7f864750 // .quad 5163053903184807760 + QUAD $0x85a36366eb71f041 // .quad -8817094351773372351 + QUAD $0x999090b65f67d924 // .quad -7381240676301154012 + QUAD $0xa70c3c40a64e6c51 // .quad -6409681921289327535 + QUAD $0xfff4b4e3f741cf6d // .quad -3178808521666707 + QUAD $0xd0cf4b50cfe20765 // .quad -3400416383184271515 + QUAD $0xbff8f10e7a8921a4 // .quad -4613672773753429596 + QUAD $0x82818f1281ed449f // .quad -9042789267131251553 + QUAD $0xaff72d52192b6a0d // .quad -5767090967191786995 + QUAD $0xa321f2d7226895c7 // .quad -6691800565486676537 + QUAD $0x9bf4f8a69f764490 // .quad -7208863708989733744 + QUAD $0xcbea6f8ceb02bb39 // .quad -3753064688430957767 + QUAD $0x02f236d04753d5b4 // .quad 212292400617608628 + QUAD $0xfee50b7025c36a08 // .quad -79644842111309304 + QUAD $0x01d762422c946590 // .quad 132682750386005392 + QUAD $0x9f4f2726179a2245 // .quad -6967307053960650171 + QUAD $0x424d3ad2b7b97ef5 // .quad 4777539456409894645 + QUAD $0xc722f0ef9d80aad6 // .quad -4097447799023424810 + QUAD $0xd2e0898765a7deb2 // .quad -3251447716342407502 + QUAD $0xf8ebad2b84e0d58b // .quad -510123730351893109 + QUAD $0x63cc55f49f88eb2f // .quad 7191217214140771119 + QUAD $0x9b934c3b330c8577 // .quad -7236356359111015049 + QUAD $0x3cbf6b71c76b25fb // .quad 4377335499248575995 + QUAD $0xc2781f49ffcfa6d5 // .quad -4433759430461380907 + QUAD $0x8bef464e3945ef7a // .quad -8363388681221443718 + QUAD $0xf316271c7fc3908a // .quad -930513269649338230 + QUAD $0x97758bf0e3cbb5ac // .quad -7532960934977096276 + QUAD $0x97edd871cfda3a56 // .quad -7499099821171918250 + QUAD $0x3d52eeed1cbea317 // .quad 4418856886560793367 + QUAD $0xbde94e8e43d0c8ec // .quad -4762188758037509908 + QUAD $0x4ca7aaa863ee4bdd // .quad 5523571108200991709 + QUAD $0xed63a231d4c4fb27 // .quad -1341049929119499481 + QUAD $0x8fe8caa93e74ef6a // .quad -8076983103442849942 + QUAD $0x945e455f24fb1cf8 // .quad -7755685233340769032 + QUAD $0xb3e2fd538e122b44 // .quad -5484542860876174524 + QUAD $0xb975d6b6ee39e436 // .quad -5082920523248573386 + QUAD $0x60dbbca87196b616 // .quad 6979379479186945558 + QUAD $0xe7d34c64a9c85d44 // .quad -1741964635633328828 + QUAD $0xbc8955e946fe31cd // .quad -4861259862362934835 + QUAD $0x90e40fbeea1d3a4a // .quad -8006256924911912374 + QUAD $0x6babab6398bdbe41 // .quad 7758483227328495169 + QUAD $0xb51d13aea4a488dd // .quad -5396135137712502563 + QUAD $0xc696963c7eed2dd1 // .quad -4136954021121544751 + QUAD $0xe264589a4dcdab14 // .quad -2133482903713240300 + QUAD $0xfc1e1de5cf543ca2 // .quad -279753253987271518 + QUAD $0x8d7eb76070a08aec // .quad -8250955842461857044 + QUAD $0x3b25a55f43294bcb // .quad 4261994450943298507 + QUAD $0xb0de65388cc8ada8 // .quad -5702008784649933400 + QUAD $0x49ef0eb713f39ebe // .quad 5327493063679123134 + QUAD $0xdd15fe86affad912 // .quad -2515824962385028846 + QUAD $0x6e3569326c784337 // .quad 7941369183226839863 + QUAD $0x8a2dbf142dfcc7ab // .quad -8489919629131724885 + QUAD $0x49c2c37f07965404 // .quad 5315025460606161924 + QUAD $0xacb92ed9397bf996 // .quad -6000713517987268202 + QUAD $0xdc33745ec97be906 // .quad -2579590211097073402 + QUAD $0xd7e77a8f87daf7fb // .quad -2889205879056697349 + QUAD $0x69a028bb3ded71a3 // .quad 7611128154919104931 + QUAD $0x86f0ac99b4e8dafd // .quad -8723282702051517699 + QUAD $0xc40832ea0d68ce0c // .quad -4321147861633282548 + QUAD $0xa8acd7c0222311bc // .quad -6292417359137009220 + QUAD $0xf50a3fa490c30190 // .quad -789748808614215280 + QUAD $0xd2d80db02aabd62b // .quad -3253835680493873621 + QUAD $0x792667c6da79e0fa // .quad 8729779031470891258 + QUAD $0x83c7088e1aab65db // .quad -8951176327949752869 + QUAD $0x577001b891185938 // .quad 6300537770911226168 + QUAD $0xa4b8cab1a1563f52 // .quad -6577284391509803182 + QUAD $0xed4c0226b55e6f86 // .quad -1347699823215743098 + QUAD $0xcde6fd5e09abcf26 // .quad -3609919470959866074 + QUAD $0x544f8158315b05b4 // .quad 6075216638131242420 + QUAD $0x80b05e5ac60b6178 // .quad -9173728696990998152 + QUAD $0x696361ae3db1c721 // .quad 7594020797664053025 + QUAD $0xa0dc75f1778e39d6 // .quad -6855474852811359786 + QUAD $0x03bc3a19cd1e38e9 // .quad 269153960225290473 + QUAD $0xc913936dd571c84c // .quad -3957657547586811828 + QUAD $0x04ab48a04065c723 // .quad 336442450281613091 + QUAD $0xfb5878494ace3a5f // .quad -335385916056126881 + QUAD $0x62eb0d64283f9c76 // .quad 7127805559067090038 + QUAD $0x9d174b2dcec0e47b // .quad -7127145225176161157 + QUAD $0x3ba5d0bd324f8394 // .quad 4298070930406474644 + QUAD $0xc45d1df942711d9a // .quad -4297245513042813542 + QUAD $0xca8f44ec7ee36479 // .quad -3850783373846682503 + QUAD $0xf5746577930d6500 // .quad -759870872876129024 + QUAD $0x7e998b13cf4e1ecb // .quad 9122475437414293195 + QUAD $0x9968bf6abbe85f20 // .quad -7392448323188662496 + QUAD $0x9e3fedd8c321a67e // .quad -7043649776941685122 + QUAD $0xbfc2ef456ae276e8 // .quad -4628874385558440216 + QUAD $0xc5cfe94ef3ea101e // .quad -4192876202749718498 + QUAD $0xefb3ab16c59b14a2 // .quad -1174406963520662366 + QUAD $0xbba1f1d158724a12 // .quad -4926390635932268014 + QUAD $0x95d04aee3b80ece5 // .quad -7651533379841495835 + QUAD $0x2a8a6e45ae8edc97 // .quad 3065383741939440791 + QUAD $0xbb445da9ca61281f // .quad -4952730706374481889 + QUAD $0xf52d09d71a3293bd // .quad -779956341003086915 + QUAD $0xea1575143cf97226 // .quad -1579227364540714458 + QUAD $0x593c2626705f9c56 // .quad 6430056314514152534 + QUAD $0x924d692ca61be758 // .quad -7904546130479028392 + QUAD $0x6f8b2fb00c77836c // .quad 8037570393142690668 + QUAD $0xb6e0c377cfa2e12e // .quad -5268996644671397586 + QUAD $0x0b6dfb9c0f956447 // .quad 823590954573587527 + QUAD $0xe498f455c38b997a // .quad -1974559787411859078 + QUAD $0x4724bd4189bd5eac // .quad 5126430365035880108 + QUAD $0x8edf98b59a373fec // .quad -8151628894773493780 + QUAD $0x58edec91ec2cb657 // .quad 6408037956294850135 + QUAD $0xb2977ee300c50fe7 // .quad -5577850100039479321 + QUAD $0x2f2967b66737e3ed // .quad 3398361426941174765 + QUAD $0xdf3d5e9bc0f653e1 // .quad -2360626606621961247 + QUAD $0xbd79e0d20082ee74 // .quad -4793553135802847628 + QUAD $0x8b865b215899f46c // .quad -8392920656779807636 + QUAD $0xecd8590680a3aa11 // .quad -1380255401326171631 + QUAD $0xae67f1e9aec07187 // .quad -5879464802547371641 + QUAD $0xe80e6f4820cc9495 // .quad -1725319251657714539 + QUAD $0xda01ee641a708de9 // .quad -2737644984756826647 + QUAD $0x3109058d147fdcdd // .quad 3533361486141316317 + QUAD $0x884134fe908658b2 // .quad -8628557143114098510 + QUAD $0xbd4b46f0599fd415 // .quad -4806670179178130411 + QUAD $0xaa51823e34a7eede // .quad -6174010410465235234 + QUAD $0x6c9e18ac7007c91a // .quad 7826720331309500698 + QUAD $0xd4e5e2cdc1d1ea96 // .quad -3105826994654156138 + QUAD $0x03e2cf6bc604ddb0 // .quad 280014188641050032 + QUAD $0x850fadc09923329e // .quad -8858670899299929442 + QUAD $0x84db8346b786151c // .quad -8873354301053463268 + QUAD $0xa6539930bf6bff45 // .quad -6461652605697523899 + QUAD $0xe612641865679a63 // .quad -1868320839462053277 + QUAD $0xcfe87f7cef46ff16 // .quad -3465379738694516970 + QUAD $0x4fcb7e8f3f60c07e // .quad 5749828502977298558 + QUAD $0x81f14fae158c5f6e // .quad -9083391364325154962 + QUAD $0xe3be5e330f38f09d // .quad -2036086408133152611 + QUAD $0xa26da3999aef7749 // .quad -6742553186979055799 + QUAD $0x5cadf5bfd3072cc5 // .quad 6678264026688335045 + QUAD $0xcb090c8001ab551c // .quad -3816505465296431844 + QUAD $0x73d9732fc7c8f7f6 // .quad 8347830033360418806 + QUAD $0xfdcb4fa002162a63 // .quad -158945813193151901 + QUAD $0x2867e7fddcdd9afa // .quad 2911550761636567802 + QUAD $0x9e9f11c4014dda7e // .quad -7016870160886801794 + QUAD $0xb281e1fd541501b8 // .quad -5583933584809066056 + QUAD $0xc646d63501a1511d // .quad -4159401682681114339 + QUAD $0x1f225a7ca91a4226 // .quad 2243455055843443238 + QUAD $0xf7d88bc24209a565 // .quad -587566084924005019 + QUAD $0x3375788de9b06958 // .quad 3708002419115845976 + QUAD $0x9ae757596946075f // .quad -7284757830718584993 + QUAD $0x0052d6b1641c83ae // .quad 23317005467419566 + QUAD $0xc1a12d2fc3978937 // .quad -4494261269970843337 + QUAD $0xc0678c5dbd23a49a // .quad -4582539761593113446 + QUAD $0xf209787bb47d6b84 // .quad -1006140569036166268 + QUAD $0xf840b7ba963646e0 // .quad -558244341782001952 + QUAD $0x9745eb4d50ce6332 // .quad -7546366883288685774 + QUAD $0xb650e5a93bc3d898 // .quad -5309491445654890344 + QUAD $0xbd176620a501fbff // .quad -4821272585683469313 + QUAD $0xa3e51f138ab4cebe // .quad -6636864307068612930 + QUAD $0xec5d3fa8ce427aff // .quad -1414904713676948737 + QUAD $0xc66f336c36b10137 // .quad -4148040191917883081 + QUAD $0x93ba47c980e98cdf // .quad -7801844473689174817 + QUAD $0xb80b0047445d4184 // .quad -5185050239897353852 + QUAD $0xb8a8d9bbe123f017 // .quad -5140619573684080617 + QUAD $0xa60dc059157491e5 // .quad -6481312799871692315 + QUAD $0xe6d3102ad96cec1d // .quad -1814088448677712867 + QUAD $0x87c89837ad68db2f // .quad -8662506518347195601 + QUAD $0x9043ea1ac7e41392 // .quad -8051334308064652398 + QUAD $0x29babe4598c311fb // .quad 3006924907348169211 + QUAD $0xb454e4a179dd1877 // .quad -5452481866653427593 + QUAD $0xf4296dd6fef3d67a // .quad -853029884242176390 + QUAD $0xe16a1dc9d8545e94 // .quad -2203916314889396588 + QUAD $0x1899e4a65f58660c // .quad 1772699331562333708 + QUAD $0x8ce2529e2734bb1d // .quad -8294976724446954723 + QUAD $0x5ec05dcff72e7f8f // .quad 6827560182880305039 + QUAD $0xb01ae745b101e9e4 // .quad -5757034887131305500 + QUAD $0x76707543f4fa1f73 // .quad 8534450228600381299 + QUAD $0xdc21a1171d42645d // .quad -2584607590486743971 + QUAD $0x6a06494a791c53a8 // .quad 7639874402088932264 + QUAD $0x899504ae72497eba // .quad -8532908771695296838 + QUAD $0x0487db9d17636892 // .quad 326470965756389522 + QUAD $0xabfa45da0edbde69 // .quad -6054449946191733143 + QUAD $0x45a9d2845d3c42b6 // .quad 5019774725622874806 + QUAD $0xd6f8d7509292d603 // .quad -2956376414312278525 + QUAD $0x0b8a2392ba45a9b2 // .quad 831516194300602802 + QUAD $0x865b86925b9bc5c2 // .quad -8765264286586255934 + QUAD $0x8e6cac7768d7141e // .quad -8183976793979022306 + QUAD $0xa7f26836f282b732 // .quad -6344894339805432014 + QUAD $0x3207d795430cd926 // .quad 3605087062808385830 + QUAD $0xd1ef0244af2364ff // .quad -3319431906329402113 + QUAD $0x7f44e6bd49e807b8 // .quad 9170708441896323000 + QUAD $0x8335616aed761f1f // .quad -8992173969096958177 + QUAD $0x5f16206c9c6209a6 // .quad 6851699533943015846 + QUAD $0xa402b9c5a8d3a6e7 // .quad -6628531442943809817 + QUAD $0x36dba887c37a8c0f // .quad 3952938399001381903 + QUAD $0xcd036837130890a1 // .quad -3673978285252374367 + QUAD $0xc2494954da2c9789 // .quad -4446942528265218167 + QUAD $0x802221226be55a64 // .quad -9213765455923815836 + QUAD $0xf2db9baa10b7bd6c // .quad -946992141904134804 + QUAD $0xa02aa96b06deb0fd // .quad -6905520801477381891 + QUAD $0x6f92829494e5acc7 // .quad 8039631859474607303 + QUAD $0xc83553c5c8965d3d // .quad -4020214983419339459 + QUAD $0xcb772339ba1f17f9 // .quad -3785518230938904583 + QUAD $0xfa42a8b73abbf48c // .quad -413582710846786420 + QUAD $0xff2a760414536efb // .quad -60105885123121413 + QUAD $0x9c69a97284b578d7 // .quad -7176018221920323369 + QUAD $0xfef5138519684aba // .quad -75132356403901766 + QUAD $0xc38413cf25e2d70d // .quad -4358336758973016307 + QUAD $0x7eb258665fc25d69 // .quad 9129456591349898601 + QUAD $0xf46518c2ef5b8cd1 // .quad -836234930288882479 + QUAD $0xef2f773ffbd97a61 // .quad -1211618658047395231 + QUAD $0x98bf2f79d5993802 // .quad -7440175859071633406 + QUAD $0xaafb550ffacfd8fa // .quad -6126209340986631942 + QUAD $0xbeeefb584aff8603 // .quad -4688533805412153853 + QUAD $0x95ba2a53f983cf38 // .quad -7657761676233289928 + QUAD $0xeeaaba2e5dbf6784 // .quad -1248981238337804412 + QUAD $0xdd945a747bf26183 // .quad -2480258038432112253 + QUAD $0x952ab45cfa97a0b2 // .quad -7698142301602209614 + QUAD $0x94f971119aeef9e4 // .quad -7712008566467528220 + QUAD $0xba756174393d88df // .quad -5010991858575374113 + QUAD $0x7a37cd5601aab85d // .quad 8806733365625141341 + QUAD $0xe912b9d1478ceb17 // .quad -1652053804791829737 + QUAD $0xac62e055c10ab33a // .quad -6025006692552756422 + QUAD $0x91abb422ccb812ee // .quad -7950062655635975442 + QUAD $0x577b986b314d6009 // .quad 6303799689591218185 + QUAD $0xb616a12b7fe617aa // .quad -5325892301117581398 + QUAD $0xed5a7e85fda0b80b // .quad -1343622424865753077 + QUAD $0xe39c49765fdf9d94 // .quad -2045679357969588844 + QUAD $0x14588f13be847307 // .quad 1466078993672598279 + QUAD $0x8e41ade9fbebc27d // .quad -8196078626372074883 + QUAD $0x596eb2d8ae258fc8 // .quad 6444284760518135752 + QUAD $0xb1d219647ae6b31c // .quad -5633412264537705700 + QUAD $0x6fca5f8ed9aef3bb // .quad 8055355950647669691 + QUAD $0xde469fbd99a05fe3 // .quad -2430079312244744221 + QUAD $0x25de7bb9480d5854 // .quad 2728754459941099604 + QUAD $0x8aec23d680043bee // .quad -8436328597794046994 + QUAD $0xaf561aa79a10ae6a // .quad -5812428961928401302 + QUAD $0xada72ccc20054ae9 // .quad -5933724728815170839 + QUAD $0x1b2ba1518094da04 // .quad 1957835834444274180 + QUAD $0xd910f7ff28069da4 // .quad -2805469892591575644 + QUAD $0x90fb44d2f05d0842 // .quad -7999724640327104446 + QUAD $0x87aa9aff79042286 // .quad -8670947710510816634 + QUAD $0x353a1607ac744a53 // .quad 3835402254873283155 + QUAD $0xa99541bf57452b28 // .quad -6226998619711132888 + QUAD $0x42889b8997915ce8 // .quad 4794252818591603944 + QUAD $0xd3fa922f2d1675f2 // .quad -3172062256211528206 + QUAD $0x69956135febada11 // .quad 7608094030047140369 + QUAD $0x847c9b5d7c2e09b7 // .quad -8900067937773286985 + QUAD $0x43fab9837e699095 // .quad 4898431519131537557 + QUAD $0xa59bc234db398c25 // .quad -6513398903789220827 + QUAD $0x94f967e45e03f4bb // .quad -7712018656367741765 + QUAD $0xcf02b2c21207ef2e // .quad -3530062611309138130 + QUAD $0x1d1be0eebac278f5 // .quad 2097517367411243253 + QUAD $0x8161afb94b44f57d // .quad -9123818159709293187 + QUAD $0x6462d92a69731732 // .quad 7233582727691441970 + QUAD $0xa1ba1ba79e1632dc // .quad -6793086681209228580 + QUAD $0x7d7b8f7503cfdcfe // .quad 9041978409614302462 + QUAD $0xca28a291859bbf93 // .quad -3879672333084147821 + QUAD $0x5cda735244c3d43e // .quad 6690786993590490174 + QUAD $0xfcb2cb35e702af78 // .quad -237904397927796872 + QUAD $0x3a0888136afa64a7 // .quad 4181741870994056359 + QUAD $0x9defbf01b061adab // .quad -7066219276345954901 + QUAD $0x088aaa1845b8fdd0 // .quad 615491320315182544 + QUAD $0xc56baec21c7a1916 // .quad -4221088077005055722 + QUAD $0x8aad549e57273d45 // .quad -8454007886460797627 + QUAD $0xf6c69a72a3989f5b // .quad -664674077828931749 + QUAD $0x36ac54e2f678864b // .quad 3939617107816777291 + QUAD $0x9a3c2087a63f6399 // .quad -7332950326284164199 + QUAD $0x84576a1bb416a7dd // .quad -8910536670511192099 + QUAD $0xc0cb28a98fcf3c7f // .quad -4554501889427817345 + QUAD $0x656d44a2a11c51d5 // .quad 7308573235570561493 + QUAD $0xf0fdf2d3f3c30b9f // .quad -1081441343357383777 + QUAD $0x9f644ae5a4b1b325 // .quad -6961356773836868827 + QUAD $0x969eb7c47859e743 // .quad -7593429867239446717 + QUAD $0x873d5d9f0dde1fee // .quad -8701695967296086034 + QUAD $0xbc4665b596706114 // .quad -4880101315621920492 + QUAD $0xa90cb506d155a7ea // .quad -6265433940692719638 + QUAD $0xeb57ff22fc0c7959 // .quad -1488440626100012711 + QUAD $0x09a7f12442d588f2 // .quad 695789805494438130 + QUAD $0x9316ff75dd87cbd8 // .quad -7847804418953589800 + QUAD $0x0c11ed6d538aeb2f // .quad 869737256868047663 + QUAD $0xb7dcbf5354e9bece // .quad -5198069505264599346 + QUAD $0x8f1668c8a86da5fa // .quad -8136200465769716230 + QUAD $0xe5d3ef282a242e81 // .quad -1885900863153361279 + QUAD $0xf96e017d694487bc // .quad -473439272678684740 + QUAD $0x8fa475791a569d10 // .quad -8096217067111932656 + QUAD $0x37c981dcc395a9ac // .quad 4019886927579031980 + QUAD $0xb38d92d760ec4455 // .quad -5508585315462527915 + QUAD $0x85bbe253f47b1417 // .quad -8810199395808373737 + QUAD $0xe070f78d3927556a // .quad -2274045625900771990 + QUAD $0x93956d7478ccec8e // .quad -7812217631593927538 + QUAD $0x8c469ab843b89562 // .quad -8338807543829064350 + QUAD $0x387ac8d1970027b2 // .quad 4069786015789754290 + QUAD $0xaf58416654a6babb // .quad -5811823411358942533 + QUAD $0x06997b05fcc0319e // .quad 475546501309804958 + QUAD $0xdb2e51bfe9d0696a // .quad -2653093245771290262 + QUAD $0x441fece3bdf81f03 // .quad 4908902581746016003 + QUAD $0x88fcf317f22241e2 // .quad -8575712306248138270 + QUAD $0xd527e81cad7626c3 // .quad -3087243809672255805 + QUAD $0xab3c2fddeeaad25a // .quad -6107954364382784934 + QUAD $0x8a71e223d8d3b074 // .quad -8470740780517707660 + QUAD $0xd60b3bd56a5586f1 // .quad -3023256937051093263 + QUAD $0xf6872d5667844e49 // .quad -682526969396179383 + QUAD $0x85c7056562757456 // .quad -8807064613298015146 + QUAD $0xb428f8ac016561db // .quad -5464844730172612133 + QUAD $0xa738c6bebb12d16c // .quad -6397144748195131028 + QUAD $0xe13336d701beba52 // .quad -2219369894288377262 + QUAD $0xd106f86e69d785c7 // .quad -3384744916816525881 + QUAD $0xecc0024661173473 // .quad -1387106183930235789 + QUAD $0x82a45b450226b39c // .quad -9032994600651410532 + QUAD $0x27f002d7f95d0190 // .quad 2877803288514593168 + QUAD $0xa34d721642b06084 // .quad -6679557232386875260 + QUAD $0x31ec038df7b441f4 // .quad 3597254110643241460 + QUAD $0xcc20ce9bd35c78a5 // .quad -3737760522056206171 + QUAD $0x7e67047175a15271 // .quad 9108253656731439729 + QUAD $0xff290242c83396ce // .quad -60514634142869810 + QUAD $0x0f0062c6e984d386 // .quad 1080972517029761926 + QUAD $0x9f79a169bd203e41 // .quad -6955350673980375487 + QUAD $0x52c07b78a3e60868 // .quad 5962901664714590312 + QUAD $0xc75809c42c684dd1 // .quad -4082502324048081455 + QUAD $0xa7709a56ccdf8a82 // .quad -6381430974388925822 + QUAD $0xf92e0c3537826145 // .quad -491441886632713915 + QUAD $0x88a66076400bb691 // .quad -8600080377420466543 + QUAD $0x9bbcc7a142b17ccb // .quad -7224680206786528053 + QUAD $0x6acff893d00ea435 // .quad 7696643601933968437 + QUAD $0xc2abf989935ddbfe // .quad -4419164240055772162 + QUAD $0x0583f6b8c4124d43 // .quad 397432465562684739 + QUAD $0xf356f7ebf83552fe // .quad -912269281642327298 + QUAD $0xc3727a337a8b704a // .quad -4363290727450709942 + QUAD $0x98165af37b2153de // .quad -7487697328667536418 + QUAD $0x744f18c0592e4c5c // .quad 8380944645968776284 + QUAD $0xbe1bf1b059e9a8d6 // .quad -4747935642407032618 + QUAD $0x1162def06f79df73 // .quad 1252808770606194547 + QUAD $0xeda2ee1c7064130c // .quad -1323233534581402868 + QUAD $0x8addcb5645ac2ba8 // .quad -8440366555225904216 + QUAD $0x9485d4d1c63e8be7 // .quad -7744549986754458649 + QUAD $0x6d953e2bd7173692 // .quad 7896285879677171346 + QUAD $0xb9a74a0637ce2ee1 // .quad -5069001465015685407 + QUAD $0xc8fa8db6ccdd0437 // .quad -3964700705685699529 + QUAD $0xe8111c87c5c1ba99 // .quad -1724565812842218855 + QUAD $0x1d9c9892400a22a2 // .quad 2133748077373825698 + QUAD $0x910ab1d4db9914a0 // .quad -7995382660667468640 + QUAD $0x2503beb6d00cab4b // .quad 2667185096717282123 + QUAD $0xb54d5e4a127f59c8 // .quad -5382542307406947896 + QUAD $0x2e44ae64840fd61d // .quad 3333981370896602653 + QUAD $0xe2a0b5dc971f303a // .quad -2116491865831296966 + QUAD $0x5ceaecfed289e5d2 // .quad 6695424375237764562 + QUAD $0x8da471a9de737e24 // .quad -8240336443785642460 + QUAD $0x7425a83e872c5f47 // .quad 8369280469047205703 + QUAD $0xb10d8e1456105dad // .quad -5688734536304665171 + QUAD $0xd12f124e28f77719 // .quad -3373457468973156583 + QUAD $0xdd50f1996b947518 // .quad -2499232151953443560 + QUAD $0x82bd6b70d99aaa6f // .quad -9025939945749304721 + QUAD $0x8a5296ffe33cc92f // .quad -8479549122611984081 + QUAD $0x636cc64d1001550b // .quad 7164319141522920715 + QUAD $0xace73cbfdc0bfb7b // .quad -5987750384837592197 + QUAD $0x3c47f7e05401aa4e // .quad 4343712908476262990 + QUAD $0xd8210befd30efa5a // .quad -2873001962619602342 + QUAD $0x65acfaec34810a71 // .quad 7326506586225052273 + QUAD $0x8714a775e3e95c78 // .quad -8713155254278333320 + QUAD $0x7f1839a741a14d0d // .quad 9158133232781315341 + QUAD $0xa8d9d1535ce3b396 // .quad -6279758049420528746 + QUAD $0x1ede48111209a050 // .quad 2224294504121868368 + QUAD $0xd31045a8341ca07c // .quad -3238011543348273028 + QUAD $0x934aed0aab460432 // .quad -7833187971778608078 + QUAD $0x83ea2b892091e44d // .quad -8941286242233752499 + QUAD $0xf81da84d5617853f // .quad -568112927868484289 + QUAD $0xa4e4b66b68b65d60 // .quad -6564921784364802720 + QUAD $0x36251260ab9d668e // .quad 3901544858591782542 + QUAD $0xce1de40642e3f4b9 // .quad -3594466212028615495 + QUAD $0xc1d72b7c6b426019 // .quad -4479063491021217767 + QUAD $0x80d2ae83e9ce78f3 // .quad -9164070410158966541 + QUAD $0xb24cf65b8612f81f // .quad -5598829363776522209 + QUAD $0xa1075a24e4421730 // .quad -6843401994271320272 + QUAD $0xdee033f26797b627 // .quad -2386850686293264857 + QUAD $0xc94930ae1d529cfc // .quad -3942566474411762436 + QUAD $0x169840ef017da3b1 // .quad 1628122660560806833 + QUAD $0xfb9b7cd9a4a7443c // .quad -316522074587315140 + QUAD $0x8e1f289560ee864e // .quad -8205795374004271538 + QUAD $0x9d412e0806e88aa5 // .quad -7115355324258153819 + QUAD $0xf1a6f2bab92a27e2 // .quad -1033872180650563614 + QUAD $0xc491798a08a2ad4e // .quad -4282508136895304370 + QUAD $0xae10af696774b1db // .quad -5904026244240592421 + QUAD $0xf5b5d7ec8acb58a2 // .quad -741449152691742558 + QUAD $0xacca6da1e0a8ef29 // .quad -5995859411864064215 + QUAD $0x9991a6f3d6bf1765 // .quad -7380934748073420955 + QUAD $0x17fd090a58d32af3 // .quad 1728547772024695539 + QUAD $0xbff610b0cc6edd3f // .quad -4614482416664388289 + QUAD $0xddfc4b4cef07f5b0 // .quad -2451001303396518480 + QUAD $0xeff394dcff8a948e // .quad -1156417002403097458 + QUAD $0x4abdaf101564f98e // .quad 5385653213018257806 + QUAD $0x95f83d0a1fb69cd9 // .quad -7640289654143017767 + QUAD $0x9d6d1ad41abe37f1 // .quad -7102991539009341455 + QUAD $0xbb764c4ca7a4440f // .quad -4938676049251384305 + QUAD $0x84c86189216dc5ed // .quad -8878739423761676819 + QUAD $0xea53df5fd18d5513 // .quad -1561659043136842477 + QUAD $0x32fd3cf5b4e49bb4 // .quad 3674159897003727796 + QUAD $0x92746b9be2f8552c // .quad -7893565929601608404 + QUAD $0x3fbc8c33221dc2a1 // .quad 4592699871254659745 + QUAD $0xb7118682dbb66a77 // .quad -5255271393574622601 + QUAD $0x0fabaf3feaa5334a // .quad 1129188820640936778 + QUAD $0xe4d5e82392a40515 // .quad -1957403223540890347 + QUAD $0x29cb4d87f2a7400e // .quad 3011586022114279438 + QUAD $0x8f05b1163ba6832d // .quad -8140906042354138323 + QUAD $0x743e20e9ef511012 // .quad 8376168546070237202 + QUAD $0xb2c71d5bca9023f8 // .quad -5564446534515285000 + QUAD $0x914da9246b255416 // .quad -7976533391121755114 + QUAD $0xdf78e4b2bd342cf6 // .quad -2343872149716718346 + QUAD $0x1ad089b6c2f7548e // .quad 1932195658189984910 + QUAD $0x8bab8eefb6409c1a // .quad -8382449121214030822 + QUAD $0xa184ac2473b529b1 // .quad -6808127464117294671 + QUAD $0xae9672aba3d0c320 // .quad -5866375383090150624 + QUAD $0xc9e5d72d90a2741e // .quad -3898473311719230434 + QUAD $0xda3c0f568cc4f3e8 // .quad -2721283210435300376 + QUAD $0x7e2fa67c7a658892 // .quad 9092669226243950738 + QUAD $0x8865899617fb1871 // .quad -8618331034163144591 + QUAD $0xddbb901b98feeab7 // .quad -2469221522477225289 + QUAD $0xaa7eebfb9df9de8d // .quad -6161227774276542835 + QUAD $0x552a74227f3ea565 // .quad 6136845133758244197 + QUAD $0xd51ea6fa85785631 // .quad -3089848699418290639 + QUAD $0xd53a88958f87275f // .quad -3082000819042179233 + QUAD $0x8533285c936b35de // .quad -8848684464777513506 + QUAD $0x8a892abaf368f137 // .quad -8464187042230111945 + QUAD $0xa67ff273b8460356 // .quad -6449169562544503978 + QUAD $0x2d2b7569b0432d85 // .quad 3254824252494523781 + QUAD $0xd01fef10a657842c // .quad -3449775934753242068 + QUAD $0x9c3b29620e29fc73 // .quad -7189106879045698445 + QUAD $0x8213f56a67f6b29b // .quad -9073638986861858149 + QUAD $0x8349f3ba91b47b8f // .quad -8986383598807123057 + QUAD $0xa298f2c501f45f42 // .quad -6730362715149934782 + QUAD $0x241c70a936219a73 // .quad 2602078556773259891 + QUAD $0xcb3f2f7642717713 // .quad -3801267375510030573 + QUAD $0xed238cd383aa0110 // .quad -1359087822460813040 + QUAD $0xfe0efb53d30dd4d7 // .quad -139898200960150313 + QUAD $0xf4363804324a40aa // .quad -849429889038008150 + QUAD $0x9ec95d1463e8a506 // .quad -7004965403241175802 + QUAD $0xb143c6053edcd0d5 // .quad -5673473379724898091 + QUAD $0xc67bb4597ce2ce48 // .quad -4144520735624081848 + QUAD $0xdd94b7868e94050a // .quad -2480155706228734710 + QUAD $0xf81aa16fdc1b81da // .quad -568964901102714406 + QUAD $0xca7cf2b4191c8326 // .quad -3855940325606653146 + QUAD $0x9b10a4e5e9913128 // .quad -7273132090830278360 + QUAD $0xfd1c2f611f63a3f0 // .quad -208239388580928528 + QUAD $0xc1d4ce1f63f57d72 // .quad -4479729095110460046 + QUAD $0xbc633b39673c8cec // .quad -4871985254153548564 + QUAD $0xf24a01a73cf2dccf // .quad -987975350460687153 + QUAD $0xd5be0503e085d813 // .quad -3044990783845967853 + QUAD $0x976e41088617ca01 // .quad -7535013621679011327 + QUAD $0x4b2d8644d8a74e18 // .quad 5417133557047315992 + QUAD $0xbd49d14aa79dbc82 // .quad -4807081008671376254 + QUAD $0xddf8e7d60ed1219e // .quad -2451955090545630818 + QUAD $0xec9c459d51852ba2 // .quad -1397165242411832414 + QUAD $0xcabb90e5c942b503 // .quad -3838314940804713213 + QUAD $0x93e1ab8252f33b45 // .quad -7790757304148477115 + QUAD $0x3d6a751f3b936243 // .quad 4425478360848884291 + QUAD $0xb8da1662e7b00a17 // .quad -5126760611758208489 + QUAD $0x0cc512670a783ad4 // .quad 920161932633717460 + QUAD $0xe7109bfba19c0c9d // .quad -1796764746270372707 + QUAD $0x27fb2b80668b24c5 // .quad 2880944217109767365 + QUAD $0x906a617d450187e2 // .quad -8040506994060064798 + QUAD $0xb1f9f660802dedf6 // .quad -5622191765467566602 + QUAD $0xb484f9dc9641e9da // .quad -5438947724147693094 + QUAD $0x5e7873f8a0396973 // .quad 6807318348447705459 + QUAD $0xe1a63853bbd26451 // .quad -2186998636757228463 + QUAD $0xdb0b487b6423e1e8 // .quad -2662955059861265944 + QUAD $0x8d07e33455637eb2 // .quad -8284403175614349646 + QUAD $0x91ce1a9a3d2cda62 // .quad -7940379843253970334 + QUAD $0xb049dc016abc5e5f // .quad -5743817951090549153 + QUAD $0x7641a140cc7810fb // .quad 8521269269642088699 + QUAD $0xdc5c5301c56b75f7 // .quad -2568086420435798537 + QUAD $0xa9e904c87fcb0a9d // .quad -6203421752542164323 + QUAD $0x89b9b3e11b6329ba // .quad -8522583040413455942 + QUAD $0x546345fa9fbdcd44 // .quad 6080780864604458308 + QUAD $0xac2820d9623bf429 // .quad -6041542782089432023 + QUAD $0xa97c177947ad4095 // .quad -6234081974526590827 + QUAD $0xd732290fbacaf133 // .quad -2940242459184402125 + QUAD $0x49ed8eabcccc485d // .quad 5327070802775656541 + QUAD $0x867f59a9d4bed6c0 // .quad -8755180564631333184 + QUAD $0x5c68f256bfff5a74 // .quad 6658838503469570676 + QUAD $0xa81f301449ee8c70 // .quad -6332289687361778576 + QUAD $0x73832eec6fff3111 // .quad 8323548129336963345 + QUAD $0xd226fc195c6a2f8c // .quad -3303676090774835316 + QUAD $0xc831fd53c5ff7eab // .quad -4021154456019173717 + QUAD $0x83585d8fd9c25db7 // .quad -8982326584375353929 + QUAD $0xba3e7ca8b77f5e55 // .quad -5026443070023967147 + QUAD $0xa42e74f3d032f525 // .quad -6616222212041804507 + QUAD $0x28ce1bd2e55f35eb // .quad 2940318199324816875 + QUAD $0xcd3a1230c43fb26f // .quad -3658591746624867729 + QUAD $0x7980d163cf5b81b3 // .quad 8755227902219092403 + QUAD $0x80444b5e7aa7cf85 // .quad -9204148869281624187 + QUAD $0xd7e105bcc332621f // .quad -2891023177508298209 + QUAD $0xa0555e361951c366 // .quad -6893500068174642330 + QUAD $0x8dd9472bf3fefaa7 // .quad -8225464990312760665 + QUAD $0xc86ab5c39fa63440 // .quad -4005189066790915008 + QUAD $0xb14f98f6f0feb951 // .quad -5670145219463562927 + QUAD $0xfa856334878fc150 // .quad -394800315061255856 + QUAD $0x6ed1bf9a569f33d3 // .quad 7985374283903742931 + QUAD $0x9c935e00d4b9d8d2 // .quad -7164279224554366766 + QUAD $0x0a862f80ec4700c8 // .quad 758345818024902856 + QUAD $0xc3b8358109e84f07 // .quad -4343663012265570553 + QUAD $0xcd27bb612758c0fa // .quad -3663753745896259334 + QUAD $0xf4a642e14c6262c8 // .quad -817892746904575288 + QUAD $0x8038d51cb897789c // .quad -9207375118826243940 + QUAD $0x98e7e9cccfbd7dbd // .quad -7428711994456441411 + QUAD $0xe0470a63e6bd56c3 // .quad -2285846861678029117 + QUAD $0xbf21e44003acdd2c // .quad -4674203974643163860 + QUAD $0x1858ccfce06cac74 // .quad 1754377441329851508 + QUAD $0xeeea5d5004981478 // .quad -1231068949876566920 + QUAD $0x0f37801e0c43ebc8 // .quad 1096485900831157192 + QUAD $0x95527a5202df0ccb // .quad -7686947121313936181 + QUAD $0xd30560258f54e6ba // .quad -3241078642388441414 + QUAD $0xbaa718e68396cffd // .quad -4996997883215032323 + QUAD $0x47c6b82ef32a2069 // .quad 5172023733869224041 + QUAD $0xe950df20247c83fd // .quad -1634561335591402499 + QUAD $0x4cdc331d57fa5441 // .quad 5538357842881958977 + QUAD $0x91d28b7416cdd27e // .quad -7939129862385708418 + QUAD $0xe0133fe4adf8e952 // .quad -2300424733252327086 + QUAD $0xb6472e511c81471d // .quad -5312226309554747619 + QUAD $0x58180fddd97723a6 // .quad 6347841120289366950 + QUAD $0xe3d8f9e563a198e5 // .quad -2028596868516046619 + QUAD $0x570f09eaa7ea7648 // .quad 6273243709394548296 + QUAD $0x8e679c2f5e44ff8f // .quad -8185402070463610993 + QUAD $0x2cd2cc6551e513da // .quad 3229868618315797466 + QUAD $0xb201833b35d63f73 // .quad -5620066569652125837 + QUAD $0xf8077f7ea65e58d1 // .quad -574350245532641071 + QUAD $0xde81e40a034bcf4f // .quad -2413397193637769393 + QUAD $0xfb04afaf27faf782 // .quad -358968903457900670 + QUAD $0x8b112e86420f6191 // .quad -8425902273664687727 + QUAD $0x79c5db9af1f9b563 // .quad 8774660907532399971 + QUAD $0xadd57a27d29339f6 // .quad -5920691823653471754 + QUAD $0x18375281ae7822bc // .quad 1744954097560724156 + QUAD $0xd94ad8b1c7380874 // .quad -2789178761139451788 + QUAD $0x8f2293910d0b15b5 // .quad -8132775725879323211 + QUAD $0x87cec76f1c830548 // .quad -8660765753353239224 + QUAD $0xb2eb3875504ddb22 // .quad -5554283638921766110 + QUAD $0xa9c2794ae3a3c69a // .quad -6214271173264161126 + QUAD $0x5fa60692a46151eb // .quad 6892203506629956075 + QUAD $0xd433179d9c8cb841 // .quad -3156152948152813503 + QUAD $0xdbc7c41ba6bcd333 // .quad -2609901835997359309 + QUAD $0x849feec281d7f328 // .quad -8890124620236590296 + QUAD $0x12b9b522906c0800 // .quad 1349308723430688768 + QUAD $0xa5c7ea73224deff3 // .quad -6500969756868349965 + QUAD $0xd768226b34870a00 // .quad -2925050114139026944 + QUAD $0xcf39e50feae16bef // .quad -3514526177658049553 + QUAD $0xe6a1158300d46640 // .quad -1828156321336891840 + QUAD $0x81842f29f2cce375 // .quad -9114107888677362827 + QUAD $0x60495ae3c1097fd0 // .quad 6938176635183661008 + QUAD $0xa1e53af46f801c53 // .quad -6780948842419315629 + QUAD $0x385bb19cb14bdfc4 // .quad 4061034775552188356 + QUAD $0xca5e89b18b602368 // .quad -3864500034596756632 + QUAD $0x46729e03dd9ed7b5 // .quad 5076293469440235445 + QUAD $0xfcf62c1dee382c42 // .quad -218939024818557886 + QUAD $0x6c07a2c26a8346d1 // .quad 7784369436827535057 + QUAD $0x9e19db92b4e31ba9 // .quad -7054365918152680535 + QUAD $0xc7098b7305241885 // .quad -4104596259247744891 + QUAD $0xc5a05277621be293 // .quad -4206271379263462765 + QUAD $0xb8cbee4fc66d1ea7 // .quad -5130745324059681113 + QUAD $0xf70867153aa2db38 // .quad -646153205651940552 + QUAD $0x737f74f1dc043328 // .quad 8322499218531169064 + QUAD $0x9a65406d44a5c903 // .quad -7321374781173544701 + QUAD $0x505f522e53053ff2 // .quad 5791438004736573426 + QUAD $0xc0fe908895cf3b44 // .quad -4540032458039542972 + QUAD $0x647726b9e7c68fef // .quad 7239297505920716783 + QUAD $0xf13e34aabb430a15 // .quad -1063354554122040811 + QUAD $0x5eca783430dc19f5 // .quad 6830403950414141941 + QUAD $0x96c6e0eab509e64d // .quad -7582125623967357363 + QUAD $0xb67d16413d132072 // .quad -5297053117264486286 + QUAD $0xbc789925624c5fe0 // .quad -4865971011531808800 + QUAD $0xe41c5bd18c57e88f // .quad -2009630378153219953 + QUAD $0xeb96bf6ebadf77d8 // .quad -1470777745987373096 + QUAD $0x8e91b962f7b6f159 // .quad -8173548013986844327 + QUAD $0x933e37a534cbaae7 // .quad -7836765118883190041 + QUAD $0x723627bbb5a4adb0 // .quad 8229809056225996208 + QUAD $0xb80dc58e81fe95a1 // .quad -5184270380176599647 + QUAD $0xcec3b1aaa30dd91c // .quad -3547796734999668452 + QUAD $0xe61136f2227e3b09 // .quad -1868651956793361655 + QUAD $0x213a4f0aa5e8a7b1 // .quad 2394313059052595121 + QUAD $0x8fcac257558ee4e6 // .quad -8085436500636932890 + QUAD $0xa988e2cd4f62d19d // .quad -6230480713039031907 + QUAD $0xb3bd72ed2af29e1f // .quad -5495109607368778209 + QUAD $0x93eb1b80a33b8605 // .quad -7788100891298789883 + QUAD $0xe0accfa875af45a7 // .quad -2257200990783584857 + QUAD $0xbc72f130660533c3 // .quad -4867563057061743677 + QUAD $0x8c6c01c9498d8b88 // .quad -8328279646880822392 + QUAD $0xeb8fad7c7f8680b4 // .quad -1472767802899791692 + QUAD $0xaf87023b9bf0ee6a // .quad -5798663540173640086 + QUAD $0xa67398db9f6820e1 // .quad -6452645772052127519 + QUAD $0xdb68c2ca82ed2a05 // .quad -2636643406789662203 + QUAD $0x88083f8943a1148c // .quad -8644589625959967604 + QUAD $0x892179be91d43a43 // .quad -8565431156884620733 + QUAD $0x6a0a4f6b948959b0 // .quad 7641007041259592112 + QUAD $0xab69d82e364948d4 // .quad -6095102927678388012 + QUAD $0x848ce34679abb01c // .quad -8895485272135061476 + QUAD $0xd6444e39c3db9b09 // .quad -3007192641170597111 + QUAD $0xf2d80e0c0c0b4e11 // .quad -947992276657025519 + QUAD $0x85eab0e41a6940e5 // .quad -8797024428372705051 + QUAD $0x6f8e118f0f0e2195 // .quad 8038381691033493909 + QUAD $0xa7655d1d2103911f // .quad -6384594517038493409 + QUAD $0x4b7195f2d2d1a9fb // .quad 5436291095364479483 + QUAD $0xd13eb46469447567 // .quad -3369057127870728857 + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +_POW_TAB: + LONG $0x00000001 // .long 1 + LONG $0x00000003 // .long 3 + LONG $0x00000006 // .long 6 + LONG $0x00000009 // .long 9 + LONG $0x0000000d // .long 13 + LONG $0x00000010 // .long 16 + LONG $0x00000013 // .long 19 + LONG $0x00000017 // .long 23 + LONG $0x0000001a // .long 26 + + // .p2align 2, 0x00 +_MASK_USE_NUMBER: + LONG $0x00000002 // .long 2 + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_Digits: + QUAD $0x3330323031303030; QUAD $0x3730363035303430 // .ascii 16, '0001020304050607' + QUAD $0x3131303139303830; QUAD $0x3531343133313231 // .ascii 16, '0809101112131415' + QUAD $0x3931383137313631; QUAD $0x3332323231323032 // .ascii 16, '1617181920212223' + QUAD $0x3732363235323432; QUAD $0x3133303339323832 // .ascii 16, '2425262728293031' + QUAD $0x3533343333333233; QUAD $0x3933383337333633 // .ascii 16, '3233343536373839' + QUAD $0x3334323431343034; QUAD $0x3734363435343434 // .ascii 16, '4041424344454647' + QUAD $0x3135303539343834; QUAD $0x3535343533353235 // .ascii 16, '4849505152535455' + QUAD $0x3935383537353635; QUAD $0x3336323631363036 // .ascii 16, '5657585960616263' + QUAD $0x3736363635363436; QUAD $0x3137303739363836 // .ascii 16, '6465666768697071' + QUAD $0x3537343733373237; QUAD $0x3937383737373637 // .ascii 16, '7273747576777879' + QUAD $0x3338323831383038; QUAD $0x3738363835383438 // .ascii 16, '8081828384858687' + QUAD $0x3139303939383838; QUAD $0x3539343933393239 // .ascii 16, '8889909192939495' + QUAD $0x3939383937393639 // .ascii 8, '96979899' + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_LB_a0a1aa40: // _pow10_ceil_sig.g + QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721 + QUAD $0x25e8e89c13bb0f7b // .quad 2731688931043774331 + QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807 + QUAD $0x77b191618c54e9ad // .quad 8624834609543440813 + QUAD $0xc795830d75038c1d // .quad -4065198994811024355 + QUAD $0xd59df5b9ef6a2418 // .quad -3054014793352862696 + QUAD $0xf97ae3d0d2446f25 // .quad -469812725086392539 + QUAD $0x4b0573286b44ad1e // .quad 5405853545163697438 + QUAD $0x9becce62836ac577 // .quad -7211161980820077193 + QUAD $0x4ee367f9430aec33 // .quad 5684501474941004851 + QUAD $0xc2e801fb244576d5 // .quad -4402266457597708587 + QUAD $0x229c41f793cda740 // .quad 2493940825248868160 + QUAD $0xf3a20279ed56d48a // .quad -891147053569747830 + QUAD $0x6b43527578c11110 // .quad 7729112049988473104 + QUAD $0x9845418c345644d6 // .quad -7474495936122174250 + QUAD $0x830a13896b78aaaa // .quad -9004363024039368022 + QUAD $0xbe5691ef416bd60c // .quad -4731433901725329908 + QUAD $0x23cc986bc656d554 // .quad 2579604275232953684 + QUAD $0xedec366b11c6cb8f // .quad -1302606358729274481 + QUAD $0x2cbfbe86b7ec8aa9 // .quad 3224505344041192105 + QUAD $0x94b3a202eb1c3f39 // .quad -7731658001846878407 + QUAD $0x7bf7d71432f3d6aa // .quad 8932844867666826922 + QUAD $0xb9e08a83a5e34f07 // .quad -5052886483881210105 + QUAD $0xdaf5ccd93fb0cc54 // .quad -2669001970698630060 + QUAD $0xe858ad248f5c22c9 // .quad -1704422086424124727 + QUAD $0xd1b3400f8f9cff69 // .quad -3336252463373287575 + QUAD $0x91376c36d99995be // .quad -7982792831656159810 + QUAD $0x23100809b9c21fa2 // .quad 2526528228819083170 + QUAD $0xb58547448ffffb2d // .quad -5366805021142811859 + QUAD $0xabd40a0c2832a78b // .quad -6065211750830921845 + QUAD $0xe2e69915b3fff9f9 // .quad -2096820258001126919 + QUAD $0x16c90c8f323f516d // .quad 1641857348316123501 + QUAD $0x8dd01fad907ffc3b // .quad -8228041688891786181 + QUAD $0xae3da7d97f6792e4 // .quad -5891368184943504668 + QUAD $0xb1442798f49ffb4a // .quad -5673366092687344822 + QUAD $0x99cd11cfdf41779d // .quad -7364210231179380835 + QUAD $0xdd95317f31c7fa1d // .quad -2480021597431793123 + QUAD $0x40405643d711d584 // .quad 4629795266307937668 + QUAD $0x8a7d3eef7f1cfc52 // .quad -8467542526035952558 + QUAD $0x482835ea666b2573 // .quad 5199465050656154995 + QUAD $0xad1c8eab5ee43b66 // .quad -5972742139117552794 + QUAD $0xda3243650005eed0 // .quad -2724040723534582064 + QUAD $0xd863b256369d4a40 // .quad -2854241655469553088 + QUAD $0x90bed43e40076a83 // .quad -8016736922845615485 + QUAD $0x873e4f75e2224e68 // .quad -8701430062309552536 + QUAD $0x5a7744a6e804a292 // .quad 6518754469289960082 + QUAD $0xa90de3535aaae202 // .quad -6265101559459552766 + QUAD $0x711515d0a205cb37 // .quad 8148443086612450103 + QUAD $0xd3515c2831559a83 // .quad -3219690930897053053 + QUAD $0x0d5a5b44ca873e04 // .quad 962181821410786820 + QUAD $0x8412d9991ed58091 // .quad -8929835859451740015 + QUAD $0xe858790afe9486c3 // .quad -1704479370831952189 + QUAD $0xa5178fff668ae0b6 // .quad -6550608805887287114 + QUAD $0x626e974dbe39a873 // .quad 7092772823314835571 + QUAD $0xce5d73ff402d98e3 // .quad -3576574988931720989 + QUAD $0xfb0a3d212dc81290 // .quad -357406007711231344 + QUAD $0x80fa687f881c7f8e // .quad -9152888395723407474 + QUAD $0x7ce66634bc9d0b9a // .quad 8999993282035256218 + QUAD $0xa139029f6a239f72 // .quad -6829424476226871438 + QUAD $0x1c1fffc1ebc44e81 // .quad 2026619565689294465 + QUAD $0xc987434744ac874e // .quad -3925094576856201394 + QUAD $0xa327ffb266b56221 // .quad -6690097579743157727 + QUAD $0xfbe9141915d7a922 // .quad -294682202642863838 + QUAD $0x4bf1ff9f0062baa9 // .quad 5472436080603216553 + QUAD $0x9d71ac8fada6c9b5 // .quad -7101705404292871755 + QUAD $0x6f773fc3603db4aa // .quad 8031958568804398250 + QUAD $0xc4ce17b399107c22 // .quad -4265445736938701790 + QUAD $0xcb550fb4384d21d4 // .quad -3795109844276665900 + QUAD $0xf6019da07f549b2b // .quad -720121152745989333 + QUAD $0x7e2a53a146606a49 // .quad 9091170749936331337 + QUAD $0x99c102844f94e0fb // .quad -7367604748107325189 + QUAD $0x2eda7444cbfc426e // .quad 3376138709496513134 + QUAD $0xc0314325637a1939 // .quad -4597819916706768583 + QUAD $0xfa911155fefb5309 // .quad -391512631556746487 + QUAD $0xf03d93eebc589f88 // .quad -1135588877456072824 + QUAD $0x793555ab7eba27cb // .quad 8733981247408842699 + QUAD $0x96267c7535b763b5 // .quad -7627272076051127371 + QUAD $0x4bc1558b2f3458df // .quad 5458738279630526687 + QUAD $0xbbb01b9283253ca2 // .quad -4922404076636521310 + QUAD $0x9eb1aaedfb016f17 // .quad -7011635205744005353 + QUAD $0xea9c227723ee8bcb // .quad -1541319077368263733 + QUAD $0x465e15a979c1cadd // .quad 5070514048102157021 + QUAD $0x92a1958a7675175f // .quad -7880853450996246689 + QUAD $0x0bfacd89ec191eca // .quad 863228270850154186 + QUAD $0xb749faed14125d36 // .quad -5239380795317920458 + QUAD $0xcef980ec671f667c // .quad -3532650679864695172 + QUAD $0xe51c79a85916f484 // .quad -1937539975720012668 + QUAD $0x82b7e12780e7401b // .quad -9027499368258256869 + QUAD $0x8f31cc0937ae58d2 // .quad -8128491512466089774 + QUAD $0xd1b2ecb8b0908811 // .quad -3336344095947716591 + QUAD $0xb2fe3f0b8599ef07 // .quad -5548928372155224313 + QUAD $0x861fa7e6dcb4aa16 // .quad -8782116138362033642 + QUAD $0xdfbdcece67006ac9 // .quad -2324474446766642487 + QUAD $0x67a791e093e1d49b // .quad 7469098900757009563 + QUAD $0x8bd6a141006042bd // .quad -8370325556870233411 + QUAD $0xe0c8bb2c5c6d24e1 // .quad -2249342214667950879 + QUAD $0xaecc49914078536d // .quad -5851220927660403859 + QUAD $0x58fae9f773886e19 // .quad 6411694268519837209 + QUAD $0xda7f5bf590966848 // .quad -2702340141148116920 + QUAD $0xaf39a475506a899f // .quad -5820440219632367201 + QUAD $0x888f99797a5e012d // .quad -8606491615858654931 + QUAD $0x6d8406c952429604 // .quad 7891439908798240260 + QUAD $0xaab37fd7d8f58178 // .quad -6146428501395930760 + QUAD $0xc8e5087ba6d33b84 // .quad -3970758169284363388 + QUAD $0xd5605fcdcf32e1d6 // .quad -3071349608317525546 + QUAD $0xfb1e4a9a90880a65 // .quad -351761693178066331 + QUAD $0x855c3be0a17fcd26 // .quad -8837122532839535322 + QUAD $0x5cf2eea09a550680 // .quad 6697677969404790400 + QUAD $0xa6b34ad8c9dfc06f // .quad -6434717147622031249 + QUAD $0xf42faa48c0ea481f // .quad -851274575098787809 + QUAD $0xd0601d8efc57b08b // .quad -3431710416100151157 + QUAD $0xf13b94daf124da27 // .quad -1064093218873484761 + QUAD $0x823c12795db6ce57 // .quad -9062348037703676329 + QUAD $0x76c53d08d6b70859 // .quad 8558313775058847833 + QUAD $0xa2cb1717b52481ed // .quad -6716249028702207507 + QUAD $0x54768c4b0c64ca6f // .quad 6086206200396171887 + QUAD $0xcb7ddcdda26da268 // .quad -3783625267450371480 + QUAD $0xa9942f5dcf7dfd0a // .quad -6227300304786948854 + QUAD $0xfe5d54150b090b02 // .quad -117845565885576446 + QUAD $0xd3f93b35435d7c4d // .quad -3172439362556298163 + QUAD $0x9efa548d26e5a6e1 // .quad -6991182506319567135 + QUAD $0xc47bc5014a1a6db0 // .quad -4288617610811380304 + QUAD $0xc6b8e9b0709f109a // .quad -4127292114472071014 + QUAD $0x359ab6419ca1091c // .quad 3862600023340550428 + QUAD $0xf867241c8cc6d4c0 // .quad -547429124662700864 + QUAD $0xc30163d203c94b63 // .quad -4395122007679087773 + QUAD $0x9b407691d7fc44f8 // .quad -7259672230555269896 + QUAD $0x79e0de63425dcf1e // .quad 8782263791269039902 + QUAD $0xc21094364dfb5636 // .quad -4462904269766699466 + QUAD $0x985915fc12f542e5 // .quad -7468914334623251739 + QUAD $0xf294b943e17a2bc4 // .quad -966944318780986428 + QUAD $0x3e6f5b7b17b2939e // .quad 4498915137003099038 + QUAD $0x979cf3ca6cec5b5a // .quad -7521869226879198374 + QUAD $0xa705992ceecf9c43 // .quad -6411550076227838909 + QUAD $0xbd8430bd08277231 // .quad -4790650515171610063 + QUAD $0x50c6ff782a838354 // .quad 5820620459997365076 + QUAD $0xece53cec4a314ebd // .quad -1376627125537124675 + QUAD $0xa4f8bf5635246429 // .quad -6559282480285457367 + QUAD $0x940f4613ae5ed136 // .quad -7777920981101784778 + QUAD $0x871b7795e136be9a // .quad -8711237568605798758 + QUAD $0xb913179899f68584 // .quad -5110715207949843068 + QUAD $0x28e2557b59846e40 // .quad 2946011094524915264 + QUAD $0xe757dd7ec07426e5 // .quad -1776707991509915931 + QUAD $0x331aeada2fe589d0 // .quad 3682513868156144080 + QUAD $0x9096ea6f3848984f // .quad -8027971522334779313 + QUAD $0x3ff0d2c85def7622 // .quad 4607414176811284002 + QUAD $0xb4bca50b065abe63 // .quad -5423278384491086237 + QUAD $0x0fed077a756b53aa // .quad 1147581702586717098 + QUAD $0xe1ebce4dc7f16dfb // .quad -2167411962186469893 + QUAD $0xd3e8495912c62895 // .quad -3177208890193991531 + QUAD $0x8d3360f09cf6e4bd // .quad -8272161504007625539 + QUAD $0x64712dd7abbbd95d // .quad 7237616480483531101 + QUAD $0xb080392cc4349dec // .quad -5728515861582144020 + QUAD $0xbd8d794d96aacfb4 // .quad -4788037454677749836 + QUAD $0xdca04777f541c567 // .quad -2548958808550292121 + QUAD $0xecf0d7a0fc5583a1 // .quad -1373360799919799391 + QUAD $0x89e42caaf9491b60 // .quad -8510628282985014432 + QUAD $0xf41686c49db57245 // .quad -858350499949874619 + QUAD $0xac5d37d5b79b6239 // .quad -6026599335303880135 + QUAD $0x311c2875c522ced6 // .quad 3538747893490044630 + QUAD $0xd77485cb25823ac7 // .quad -2921563150702462265 + QUAD $0x7d633293366b828c // .quad 9035120885289943692 + QUAD $0x86a8d39ef77164bc // .quad -8743505996830120772 + QUAD $0xae5dff9c02033198 // .quad -5882264492762254952 + QUAD $0xa8530886b54dbdeb // .quad -6317696477610263061 + QUAD $0xd9f57f830283fdfd // .quad -2741144597525430787 + QUAD $0xd267caa862a12d66 // .quad -3285434578585440922 + QUAD $0xd072df63c324fd7c // .quad -3426430746906788484 + QUAD $0x8380dea93da4bc60 // .quad -8970925639256982432 + QUAD $0x4247cb9e59f71e6e // .quad 4776009810824339054 + QUAD $0xa46116538d0deb78 // .quad -6601971030643840136 + QUAD $0x52d9be85f074e609 // .quad 5970012263530423817 + QUAD $0xcd795be870516656 // .quad -3640777769877412266 + QUAD $0x67902e276c921f8c // .quad 7462515329413029772 + QUAD $0x806bd9714632dff6 // .quad -9193015133814464522 + QUAD $0x00ba1cd8a3db53b7 // .quad 52386062455755703 + QUAD $0xa086cfcd97bf97f3 // .quad -6879582898840692749 + QUAD $0x80e8a40eccd228a5 // .quad -9157889458785081179 + QUAD $0xc8a883c0fdaf7df0 // .quad -3987792605123478032 + QUAD $0x6122cd128006b2ce // .quad 6999382250228200142 + QUAD $0xfad2a4b13d1b5d6c // .quad -373054737976959636 + QUAD $0x796b805720085f82 // .quad 8749227812785250178 + QUAD $0x9cc3a6eec6311a63 // .quad -7150688238876681629 + QUAD $0xcbe3303674053bb1 // .quad -3755104653863994447 + QUAD $0xc3f490aa77bd60fc // .quad -4326674280168464132 + QUAD $0xbedbfc4411068a9d // .quad -4693880817329993059 + QUAD $0xf4f1b4d515acb93b // .quad -796656831783192261 + QUAD $0xee92fb5515482d45 // .quad -1255665003235103419 + QUAD $0x991711052d8bf3c5 // .quad -7415439547505577019 + QUAD $0x751bdd152d4d1c4b // .quad 8438581409832836171 + QUAD $0xbf5cd54678eef0b6 // .quad -4657613415954583370 + QUAD $0xd262d45a78a0635e // .quad -3286831292991118498 + QUAD $0xef340a98172aace4 // .quad -1210330751515841308 + QUAD $0x86fb897116c87c35 // .quad -8720225134666286027 + QUAD $0x9580869f0e7aac0e // .quad -7673985747338482674 + QUAD $0xd45d35e6ae3d4da1 // .quad -3144297699952734815 + QUAD $0xbae0a846d2195712 // .quad -4980796165745715438 + QUAD $0x8974836059cca10a // .quad -8542058143368306422 + QUAD $0xe998d258869facd7 // .quad -1614309188754756393 + QUAD $0x2bd1a438703fc94c // .quad 3157485376071780684 + QUAD $0x91ff83775423cc06 // .quad -7926472270612804602 + QUAD $0x7b6306a34627ddd0 // .quad 8890957387685944784 + QUAD $0xb67f6455292cbf08 // .quad -5296404319838617848 + QUAD $0x1a3bc84c17b1d543 // .quad 1890324697752655171 + QUAD $0xe41f3d6a7377eeca // .quad -2008819381370884406 + QUAD $0x20caba5f1d9e4a94 // .quad 2362905872190818964 + QUAD $0x8e938662882af53e // .quad -8173041140997884610 + QUAD $0x547eb47b7282ee9d // .quad 6088502188546649757 + QUAD $0xb23867fb2a35b28d // .quad -5604615407819967859 + QUAD $0xe99e619a4f23aa44 // .quad -1612744301171463612 + QUAD $0xdec681f9f4c31f31 // .quad -2394083241347571919 + QUAD $0x6405fa00e2ec94d5 // .quad 7207441660390446293 + QUAD $0x8b3c113c38f9f37e // .quad -8413831053483314306 + QUAD $0xde83bc408dd3dd05 // .quad -2412877989897052923 + QUAD $0xae0b158b4738705e // .quad -5905602798426754978 + QUAD $0x9624ab50b148d446 // .quad -7627783505798704058 + QUAD $0xd98ddaee19068c76 // .quad -2770317479606055818 + QUAD $0x3badd624dd9b0958 // .quad 4300328673033783640 + QUAD $0x87f8a8d4cfa417c9 // .quad -8648977452394866743 + QUAD $0xe54ca5d70a80e5d7 // .quad -1923980597781273129 + QUAD $0xa9f6d30a038d1dbc // .quad -6199535797066195524 + QUAD $0x5e9fcf4ccd211f4d // .quad 6818396289628184397 + QUAD $0xd47487cc8470652b // .quad -3137733727905356501 + QUAD $0x7647c32000696720 // .quad 8522995362035230496 + QUAD $0x84c8d4dfd2c63f3b // .quad -8878612607581929669 + QUAD $0x29ecd9f40041e074 // .quad 3021029092058325108 + QUAD $0xa5fb0a17c777cf09 // .quad -6486579741050024183 + QUAD $0xf468107100525891 // .quad -835399653354481519 + QUAD $0xcf79cc9db955c2cc // .quad -3496538657885142324 + QUAD $0x7182148d4066eeb5 // .quad 8179122470161673909 + QUAD $0x81ac1fe293d599bf // .quad -9102865688819295809 + QUAD $0xc6f14cd848405531 // .quad -4111420493003729615 + QUAD $0xa21727db38cb002f // .quad -6766896092596731857 + QUAD $0xb8ada00e5a506a7d // .quad -5139275616254662019 + QUAD $0xca9cf1d206fdc03b // .quad -3846934097318526917 + QUAD $0xa6d90811f0e4851d // .quad -6424094520318327523 + QUAD $0xfd442e4688bd304a // .quad -196981603220770742 + QUAD $0x908f4a166d1da664 // .quad -8030118150397909404 + QUAD $0x9e4a9cec15763e2e // .quad -7040642529654063570 + QUAD $0x9a598e4e043287ff // .quad -7324666853212387329 + QUAD $0xc5dd44271ad3cdba // .quad -4189117143640191558 + QUAD $0x40eff1e1853f29fe // .quad 4679224488766679550 + QUAD $0xf7549530e188c128 // .quad -624710411122851544 + QUAD $0xd12bee59e68ef47d // .quad -3374341425896426371 + QUAD $0x9a94dd3e8cf578b9 // .quad -7307973034592864071 + QUAD $0x82bb74f8301958cf // .quad -9026492418826348337 + QUAD $0xc13a148e3032d6e7 // .quad -4523280274813692185 + QUAD $0xe36a52363c1faf02 // .quad -2059743486678159614 + QUAD $0xf18899b1bc3f8ca1 // .quad -1042414325089727327 + QUAD $0xdc44e6c3cb279ac2 // .quad -2574679358347699518 + QUAD $0x96f5600f15a7b7e5 // .quad -7569037980822161435 + QUAD $0x29ab103a5ef8c0ba // .quad 3002511419460075706 + QUAD $0xbcb2b812db11a5de // .quad -4849611457600313890 + QUAD $0x7415d448f6b6f0e8 // .quad 8364825292752482536 + QUAD $0xebdf661791d60f56 // .quad -1450328303573004458 + QUAD $0x111b495b3464ad22 // .quad 1232659579085827362 + QUAD $0x936b9fcebb25c995 // .quad -7823984217374209643 + QUAD $0xcab10dd900beec35 // .quad -3841273781498745803 + QUAD $0xb84687c269ef3bfb // .quad -5168294253290374149 + QUAD $0x3d5d514f40eea743 // .quad 4421779809981343555 + QUAD $0xe65829b3046b0afa // .quad -1848681798185579782 + QUAD $0x0cb4a5a3112a5113 // .quad 915538744049291539 + QUAD $0x8ff71a0fe2c2e6dc // .quad -8072955151507069220 + QUAD $0x47f0e785eaba72ac // .quad 5183897733458195116 + QUAD $0xb3f4e093db73a093 // .quad -5479507920956448621 + QUAD $0x59ed216765690f57 // .quad 6479872166822743895 + QUAD $0xe0f218b8d25088b8 // .quad -2237698882768172872 + QUAD $0x306869c13ec3532d // .quad 3488154190101041965 + QUAD $0x8c974f7383725573 // .quad -8316090829371189901 + QUAD $0x1e414218c73a13fc // .quad 2180096368813151228 + QUAD $0xafbd2350644eeacf // .quad -5783427518286599473 + QUAD $0xe5d1929ef90898fb // .quad -1886565557410948869 + QUAD $0xdbac6c247d62a583 // .quad -2617598379430861437 + QUAD $0xdf45f746b74abf3a // .quad -2358206946763686086 + QUAD $0x894bc396ce5da772 // .quad -8553528014785370254 + QUAD $0x6b8bba8c328eb784 // .quad 7749492695127472004 + QUAD $0xab9eb47c81f5114f // .quad -6080224000054324913 + QUAD $0x066ea92f3f326565 // .quad 463493832054564197 + QUAD $0xd686619ba27255a2 // .quad -2988593981640518238 + QUAD $0xc80a537b0efefebe // .quad -4032318728359182658 + QUAD $0x8613fd0145877585 // .quad -8785400266166405755 + QUAD $0xbd06742ce95f5f37 // .quad -4826042214438183113 + QUAD $0xa798fc4196e952e7 // .quad -6370064314280619289 + QUAD $0x2c48113823b73705 // .quad 3190819268807046917 + QUAD $0xd17f3b51fca3a7a0 // .quad -3350894374423386208 + QUAD $0xf75a15862ca504c6 // .quad -623161932418579258 + QUAD $0x82ef85133de648c4 // .quad -9011838011655698236 + QUAD $0x9a984d73dbe722fc // .quad -7307005235402693892 + QUAD $0xa3ab66580d5fdaf5 // .quad -6653111496142234891 + QUAD $0xc13e60d0d2e0ebbb // .quad -4522070525825979461 + QUAD $0xcc963fee10b7d1b3 // .quad -3704703351750405709 + QUAD $0x318df905079926a9 // .quad 3570783879572301481 + QUAD $0xffbbcfe994e5c61f // .quad -19193171260619233 + QUAD $0xfdf17746497f7053 // .quad -148206168962011053 + QUAD $0x9fd561f1fd0f9bd3 // .quad -6929524759678968877 + QUAD $0xfeb6ea8bedefa634 // .quad -92628855601256908 + QUAD $0xc7caba6e7c5382c8 // .quad -4050219931171323192 + QUAD $0xfe64a52ee96b8fc1 // .quad -115786069501571135 + QUAD $0xf9bd690a1b68637b // .quad -451088895536766085 + QUAD $0x3dfdce7aa3c673b1 // .quad 4466953431550423985 + QUAD $0x9c1661a651213e2d // .quad -7199459587351560659 + QUAD $0x06bea10ca65c084f // .quad 486002885505321039 + QUAD $0xc31bfa0fe5698db8 // .quad -4387638465762062920 + QUAD $0x486e494fcff30a63 // .quad 5219189625309039203 + QUAD $0xf3e2f893dec3f126 // .quad -872862063775190746 + QUAD $0x5a89dba3c3efccfb // .quad 6523987031636299003 + QUAD $0x986ddb5c6b3a76b7 // .quad -7463067817500576073 + QUAD $0xf89629465a75e01d // .quad -534194123654701027 + QUAD $0xbe89523386091465 // .quad -4717148753448332187 + QUAD $0xf6bbb397f1135824 // .quad -667742654568376284 + QUAD $0xee2ba6c0678b597f // .quad -1284749923383027329 + QUAD $0x746aa07ded582e2d // .quad 8388693718644305453 + QUAD $0x94db483840b717ef // .quad -7720497729755473937 + QUAD $0xa8c2a44eb4571cdd // .quad -6286281471915778851 + QUAD $0xba121a4650e4ddeb // .quad -5038936143766954517 + QUAD $0x92f34d62616ce414 // .quad -7857851839894723564 + QUAD $0xe896a0d7e51e1566 // .quad -1686984161281305242 + QUAD $0x77b020baf9c81d18 // .quad 8624429273841147160 + QUAD $0x915e2486ef32cd60 // .quad -7971894128441897632 + QUAD $0x0ace1474dc1d122f // .quad 778582277723329071 + QUAD $0xb5b5ada8aaff80b8 // .quad -5353181642124984136 + QUAD $0x0d819992132456bb // .quad 973227847154161339 + QUAD $0xe3231912d5bf60e6 // .quad -2079791034228842266 + QUAD $0x10e1fff697ed6c6a // .quad 1216534808942701674 + QUAD $0x8df5efabc5979c8f // .quad -8217398424034108273 + QUAD $0xca8d3ffa1ef463c2 // .quad -3851351762838199358 + QUAD $0xb1736b96b6fd83b3 // .quad -5660062011615247437 + QUAD $0xbd308ff8a6b17cb3 // .quad -4814189703547749197 + QUAD $0xddd0467c64bce4a0 // .quad -2463391496091671392 + QUAD $0xac7cb3f6d05ddbdf // .quad -6017737129434686497 + QUAD $0x8aa22c0dbef60ee4 // .quad -8457148712698376476 + QUAD $0x6bcdf07a423aa96c // .quad 7768129340171790700 + QUAD $0xad4ab7112eb3929d // .quad -5959749872445582691 + QUAD $0x86c16c98d2c953c7 // .quad -8736582398494813241 + QUAD $0xd89d64d57a607744 // .quad -2838001322129590460 + QUAD $0xe871c7bf077ba8b8 // .quad -1697355961263740744 + QUAD $0x87625f056c7c4a8b // .quad -8691279853972075893 + QUAD $0x11471cd764ad4973 // .quad 1244995533423855987 + QUAD $0xa93af6c6c79b5d2d // .quad -6252413799037706963 + QUAD $0xd598e40d3dd89bd0 // .quad -3055441601647567920 + QUAD $0xd389b47879823479 // .quad -3203831230369745799 + QUAD $0x4aff1d108d4ec2c4 // .quad 5404070034795315908 + QUAD $0x843610cb4bf160cb // .quad -8919923546622172981 + QUAD $0xcedf722a585139bb // .quad -3539985255894009413 + QUAD $0xa54394fe1eedb8fe // .quad -6538218414850328322 + QUAD $0xc2974eb4ee658829 // .quad -4424981569867511767 + QUAD $0xce947a3da6a9273e // .quad -3561087000135522498 + QUAD $0x733d226229feea33 // .quad 8303831092947774003 + QUAD $0x811ccc668829b887 // .quad -9143208402725783417 + QUAD $0x0806357d5a3f5260 // .quad 578208414664970848 + QUAD $0xa163ff802a3426a8 // .quad -6817324484979841368 + QUAD $0xca07c2dcb0cf26f8 // .quad -3888925500096174344 + QUAD $0xc9bcff6034c13052 // .quad -3909969587797413806 + QUAD $0xfc89b393dd02f0b6 // .quad -249470856692830026 + QUAD $0xfc2c3f3841f17c67 // .quad -275775966319379353 + QUAD $0xbbac2078d443ace3 // .quad -4923524589293425437 + QUAD $0x9d9ba7832936edc0 // .quad -7089889006590693952 + QUAD $0xd54b944b84aa4c0e // .quad -3077202868308390898 + QUAD $0xc5029163f384a931 // .quad -4250675239810979535 + QUAD $0x0a9e795e65d4df12 // .quad 765182433041899282 + QUAD $0xf64335bcf065d37d // .quad -701658031336336515 + QUAD $0x4d4617b5ff4a16d6 // .quad 5568164059729762006 + QUAD $0x99ea0196163fa42e // .quad -7356065297226292178 + QUAD $0x504bced1bf8e4e46 // .quad 5785945546544795206 + QUAD $0xc06481fb9bcf8d39 // .quad -4583395603105477319 + QUAD $0xe45ec2862f71e1d7 // .quad -1990940103673781801 + QUAD $0xf07da27a82c37088 // .quad -1117558485454458744 + QUAD $0x5d767327bb4e5a4d // .quad 6734696907262548557 + QUAD $0x964e858c91ba2655 // .quad -7616003081050118571 + QUAD $0x3a6a07f8d510f870 // .quad 4209185567039092848 + QUAD $0xbbe226efb628afea // .quad -4908317832885260310 + QUAD $0x890489f70a55368c // .quad -8573576096483297652 + QUAD $0xeadab0aba3b2dbe5 // .quad -1523711272679187483 + QUAD $0x2b45ac74ccea842f // .quad 3118087934678041647 + QUAD $0x92c8ae6b464fc96f // .quad -7869848573065574033 + QUAD $0x3b0b8bc90012929e // .quad 4254647968387469982 + QUAD $0xb77ada0617e3bbcb // .quad -5225624697904579637 + QUAD $0x09ce6ebb40173745 // .quad 706623942056949573 + QUAD $0xe55990879ddcaabd // .quad -1920344853953336643 + QUAD $0xcc420a6a101d0516 // .quad -3728406090856200938 + QUAD $0x8f57fa54c2a9eab6 // .quad -8117744561361917258 + QUAD $0x9fa946824a12232e // .quad -6941939825212513490 + QUAD $0xb32df8e9f3546564 // .quad -5535494683275008668 + QUAD $0x47939822dc96abfa // .quad 5157633273766521850 + QUAD $0xdff9772470297ebd // .quad -2307682335666372931 + QUAD $0x59787e2b93bc56f8 // .quad 6447041592208152312 + QUAD $0x8bfbea76c619ef36 // .quad -8359830487432564938 + QUAD $0x57eb4edb3c55b65b // .quad 6335244004343789147 + QUAD $0xaefae51477a06b03 // .quad -5838102090863318269 + QUAD $0xede622920b6b23f2 // .quad -1304317031425039374 + QUAD $0xdab99e59958885c4 // .quad -2685941595151759932 + QUAD $0xe95fab368e45ecee // .quad -1630396289281299218 + QUAD $0x88b402f7fd75539b // .quad -8596242524610931813 + QUAD $0x11dbcb0218ebb415 // .quad 1286845328412881941 + QUAD $0xaae103b5fcd2a881 // .quad -6133617137336276863 + QUAD $0xd652bdc29f26a11a // .quad -3003129357911285478 + QUAD $0xd59944a37c0752a2 // .quad -3055335403242958174 + QUAD $0x4be76d3346f04960 // .quad 5469460339465668960 + QUAD $0x857fcae62d8493a5 // .quad -8827113654667930715 + QUAD $0x6f70a4400c562ddc // .quad 8030098730593431004 + QUAD $0xa6dfbd9fb8e5b88e // .quad -6422206049907525490 + QUAD $0xcb4ccd500f6bb953 // .quad -3797434642040374957 + QUAD $0xd097ad07a71f26b2 // .quad -3416071543957018958 + QUAD $0x7e2000a41346a7a8 // .quad 9088264752731695016 + QUAD $0x825ecc24c873782f // .quad -9052573742614218705 + QUAD $0x8ed400668c0c28c9 // .quad -8154892584824854327 + QUAD $0xa2f67f2dfa90563b // .quad -6704031159840385477 + QUAD $0x728900802f0f32fb // .quad 8253128342678483707 + QUAD $0xcbb41ef979346bca // .quad -3768352931373093942 + QUAD $0x4f2b40a03ad2ffba // .quad 5704724409920716730 + QUAD $0xfea126b7d78186bc // .quad -98755145788979524 + QUAD $0xe2f610c84987bfa9 // .quad -2092466524453879895 + QUAD $0x9f24b832e6b0f436 // .quad -6979250993759194058 + QUAD $0x0dd9ca7d2df4d7ca // .quad 998051431430019018 + QUAD $0xc6ede63fa05d3143 // .quad -4112377723771604669 + QUAD $0x91503d1c79720dbc // .quad -7975807747567252036 + QUAD $0xf8a95fcf88747d94 // .quad -528786136287117932 + QUAD $0x75a44c6397ce912b // .quad 8476984389250486571 + QUAD $0x9b69dbe1b548ce7c // .quad -7248020362820530564 + QUAD $0xc986afbe3ee11abb // .quad -3925256793573221701 + QUAD $0xc24452da229b021b // .quad -4448339435098275301 + QUAD $0xfbe85badce996169 // .quad -294884973539139223 + QUAD $0xf2d56790ab41c2a2 // .quad -948738275445456222 + QUAD $0xfae27299423fb9c4 // .quad -368606216923924028 + QUAD $0x97c560ba6b0919a5 // .quad -7510490449794491995 + QUAD $0xdccd879fc967d41b // .quad -2536221894791146469 + QUAD $0xbdb6b8e905cb600f // .quad -4776427043815727089 + QUAD $0x5400e987bbc1c921 // .quad 6053094668365842721 + QUAD $0xed246723473e3813 // .quad -1358847786342270957 + QUAD $0x290123e9aab23b69 // .quad 2954682317029915497 + QUAD $0x9436c0760c86e30b // .quad -7766808894105001205 + QUAD $0xf9a0b6720aaf6522 // .quad -459166561069996766 + QUAD $0xb94470938fa89bce // .quad -5096825099203863602 + QUAD $0xf808e40e8d5b3e6a // .quad -573958201337495958 + QUAD $0xe7958cb87392c2c2 // .quad -1759345355577441598 + QUAD $0xb60b1d1230b20e05 // .quad -5329133770099257851 + QUAD $0x90bd77f3483bb9b9 // .quad -8017119874876982855 + QUAD $0xb1c6f22b5e6f48c3 // .quad -5636551615525730109 + QUAD $0xb4ecd5f01a4aa828 // .quad -5409713825168840664 + QUAD $0x1e38aeb6360b1af4 // .quad 2177682517447613172 + QUAD $0xe2280b6c20dd5232 // .quad -2150456263033662926 + QUAD $0x25c6da63c38de1b1 // .quad 2722103146809516465 + QUAD $0x8d590723948a535f // .quad -8261564192037121185 + QUAD $0x579c487e5a38ad0f // .quad 6313000485183335695 + QUAD $0xb0af48ec79ace837 // .quad -5715269221619013577 + QUAD $0x2d835a9df0c6d852 // .quad 3279564588051781714 + QUAD $0xdcdb1b2798182244 // .quad -2532400508596379068 + QUAD $0xf8e431456cf88e66 // .quad -512230283362660762 + QUAD $0x8a08f0f8bf0f156b // .quad -8500279345513818773 + QUAD $0x1b8e9ecb641b5900 // .quad 1985699082112030976 + QUAD $0xac8b2d36eed2dac5 // .quad -6013663163464885563 + QUAD $0xe272467e3d222f40 // .quad -2129562165787349184 + QUAD $0xd7adf884aa879177 // .quad -2905392935903719049 + QUAD $0x5b0ed81dcc6abb10 // .quad 6561419329620589328 + QUAD $0x86ccbb52ea94baea // .quad -8733399612580906262 + QUAD $0x98e947129fc2b4ea // .quad -7428327965055601430 + QUAD $0xa87fea27a539e9a5 // .quad -6305063497298744923 + QUAD $0x3f2398d747b36225 // .quad 4549648098962661925 + QUAD $0xd29fe4b18e88640e // .quad -3269643353196043250 + QUAD $0x8eec7f0d19a03aae // .quad -8147997931578836306 + QUAD $0x83a3eeeef9153e89 // .quad -8961056123388608887 + QUAD $0x1953cf68300424ad // .quad 1825030320404309165 + QUAD $0xa48ceaaab75a8e2b // .quad -6589634135808373205 + QUAD $0x5fa8c3423c052dd8 // .quad 6892973918932774360 + QUAD $0xcdb02555653131b6 // .quad -3625356651333078602 + QUAD $0x3792f412cb06794e // .quad 4004531380238580046 + QUAD $0x808e17555f3ebf11 // .quad -9183376934724255983 + QUAD $0xe2bbd88bbee40bd1 // .quad -2108853905778275375 + QUAD $0xa0b19d2ab70e6ed6 // .quad -6867535149977932074 + QUAD $0x5b6aceaeae9d0ec5 // .quad 6587304654631931589 + QUAD $0xc8de047564d20a8b // .quad -3972732919045027189 + QUAD $0xf245825a5a445276 // .quad -989241218564861322 + QUAD $0xfb158592be068d2e // .quad -354230130378896082 + QUAD $0xeed6e2f0f0d56713 // .quad -1236551523206076653 + QUAD $0x9ced737bb6c4183d // .quad -7138922859127891907 + QUAD $0x55464dd69685606c // .quad 6144684325637283948 + QUAD $0xc428d05aa4751e4c // .quad -4311967555482476980 + QUAD $0xaa97e14c3c26b887 // .quad -6154202648235558777 + QUAD $0xf53304714d9265df // .quad -778273425925708321 + QUAD $0xd53dd99f4b3066a9 // .quad -3081067291867060567 + QUAD $0x993fe2c6d07b7fab // .quad -7403949918844649557 + QUAD $0xe546a8038efe402a // .quad -1925667057416912854 + QUAD $0xbf8fdb78849a5f96 // .quad -4643251380128424042 + QUAD $0xde98520472bdd034 // .quad -2407083821771141068 + QUAD $0xef73d256a5c0f77c // .quad -1192378206733142148 + QUAD $0x963e66858f6d4441 // .quad -7620540795641314239 + QUAD $0x95a8637627989aad // .quad -7662765406849295699 + QUAD $0xdde7001379a44aa9 // .quad -2456994988062127447 + QUAD $0xbb127c53b17ec159 // .quad -4966770740134231719 + QUAD $0x5560c018580d5d53 // .quad 6152128301777116499 + QUAD $0xe9d71b689dde71af // .quad -1596777406740401745 + QUAD $0xaab8f01e6e10b4a7 // .quad -6144897678060768089 + QUAD $0x9226712162ab070d // .quad -7915514906853832947 + QUAD $0xcab3961304ca70e9 // .quad -3840561048787980055 + QUAD $0xb6b00d69bb55c8d1 // .quad -5282707615139903279 + QUAD $0x3d607b97c5fd0d23 // .quad 4422670725869800739 + QUAD $0xe45c10c42a2b3b05 // .quad -1991698500497491195 + QUAD $0x8cb89a7db77c506b // .quad -8306719647944912789 + QUAD $0x8eb98a7a9a5b04e3 // .quad -8162340590452013853 + QUAD $0x77f3608e92adb243 // .quad 8643358275316593219 + QUAD $0xb267ed1940f1c61c // .quad -5591239719637629412 + QUAD $0x55f038b237591ed4 // .quad 6192511825718353620 + QUAD $0xdf01e85f912e37a3 // .quad -2377363631119648861 + QUAD $0x6b6c46dec52f6689 // .quad 7740639782147942025 + QUAD $0x8b61313bbabce2c6 // .quad -8403381297090862394 + QUAD $0x2323ac4b3b3da016 // .quad 2532056854628769814 + QUAD $0xae397d8aa96c1b77 // .quad -5892540602936190089 + QUAD $0xabec975e0a0d081b // .quad -6058300968568813541 + QUAD $0xd9c7dced53c72255 // .quad -2753989735242849707 + QUAD $0x96e7bd358c904a22 // .quad -7572876210711016926 + QUAD $0x881cea14545c7575 // .quad -8638772612167862923 + QUAD $0x7e50d64177da2e55 // .quad 9102010423587778133 + QUAD $0xaa242499697392d2 // .quad -6186779746782440750 + QUAD $0xdde50bd1d5d0b9ea // .quad -2457545025797441046 + QUAD $0xd4ad2dbfc3d07787 // .quad -3121788665050663033 + QUAD $0x955e4ec64b44e865 // .quad -7683617300674189211 + QUAD $0x84ec3c97da624ab4 // .quad -8868646943297746252 + QUAD $0xbd5af13bef0b113f // .quad -4802260812921368257 + QUAD $0xa6274bbdd0fadd61 // .quad -6474122660694794911 + QUAD $0xecb1ad8aeacdd58f // .quad -1391139997724322417 + QUAD $0xcfb11ead453994ba // .quad -3480967307441105734 + QUAD $0x67de18eda5814af3 // .quad 7484447039699372787 + QUAD $0x81ceb32c4b43fcf4 // .quad -9093133594791772940 + QUAD $0x80eacf948770ced8 // .quad -9157278655470055720 + QUAD $0xa2425ff75e14fc31 // .quad -6754730975062328271 + QUAD $0xa1258379a94d028e // .quad -6834912300910181746 + QUAD $0xcad2f7f5359a3b3e // .quad -3831727700400522434 + QUAD $0x096ee45813a04331 // .quad 679731660717048625 + QUAD $0xfd87b5f28300ca0d // .quad -177973607073265139 + QUAD $0x8bca9d6e188853fd // .quad -8373707460958465027 + QUAD $0x9e74d1b791e07e48 // .quad -7028762532061872568 + QUAD $0x775ea264cf55347e // .quad 8601490892183123070 + QUAD $0xc612062576589dda // .quad -4174267146649952806 + QUAD $0x95364afe032a819e // .quad -7694880458480647778 + QUAD $0xf79687aed3eec551 // .quad -606147914885053103 + QUAD $0x3a83ddbd83f52205 // .quad 4216457482181353989 + QUAD $0x9abe14cd44753b52 // .quad -7296371474444240046 + QUAD $0xc4926a9672793543 // .quad -4282243101277735613 + QUAD $0xc16d9a0095928a27 // .quad -4508778324627912153 + QUAD $0x75b7053c0f178294 // .quad 8482254178684994196 + QUAD $0xf1c90080baf72cb1 // .quad -1024286887357502287 + QUAD $0x5324c68b12dd6339 // .quad 5991131704928854841 + QUAD $0x971da05074da7bee // .quad -7557708332239520786 + QUAD $0xd3f6fc16ebca5e04 // .quad -3173071712060547580 + QUAD $0xbce5086492111aea // .quad -4835449396872013078 + QUAD $0x88f4bb1ca6bcf585 // .quad -8578025658503072379 + QUAD $0xec1e4a7db69561a5 // .quad -1432625727662628443 + QUAD $0x2b31e9e3d06c32e6 // .quad 3112525982153323238 + QUAD $0x9392ee8e921d5d07 // .quad -7812920107430224633 + QUAD $0x3aff322e62439fd0 // .quad 4251171748059520976 + QUAD $0xb877aa3236a4b449 // .quad -5154464115860392887 + QUAD $0x09befeb9fad487c3 // .quad 702278666647013315 + QUAD $0xe69594bec44de15b // .quad -1831394126398103205 + QUAD $0x4c2ebe687989a9b4 // .quad 5489534351736154548 + QUAD $0x901d7cf73ab0acd9 // .quad -8062150356639896359 + QUAD $0x0f9d37014bf60a11 // .quad 1125115960621402641 + QUAD $0xb424dc35095cd80f // .quad -5466001927372482545 + QUAD $0x538484c19ef38c95 // .quad 6018080969204141205 + QUAD $0xe12e13424bb40e13 // .quad -2220816390788215277 + QUAD $0x2865a5f206b06fba // .quad 2910915193077788602 + QUAD $0x8cbccc096f5088cb // .quad -8305539271883716405 + QUAD $0xf93f87b7442e45d4 // .quad -486521013540076076 + QUAD $0xafebff0bcb24aafe // .quad -5770238071427257602 + QUAD $0xf78f69a51539d749 // .quad -608151266925095095 + QUAD $0xdbe6fecebdedd5be // .quad -2601111570856684098 + QUAD $0xb573440e5a884d1c // .quad -5371875102083756772 + QUAD $0x89705f4136b4a597 // .quad -8543223759426509417 + QUAD $0x31680a88f8953031 // .quad 3560107088838733873 + QUAD $0xabcc77118461cefc // .quad -6067343680855748868 + QUAD $0xfdc20d2b36ba7c3e // .quad -161552157378970562 + QUAD $0xd6bf94d5e57a42bc // .quad -2972493582642298180 + QUAD $0x3d32907604691b4d // .quad 4409745821703674701 + QUAD $0x8637bd05af6c69b5 // .quad -8775337516792518219 + QUAD $0xa63f9a49c2c1b110 // .quad -6467280898289979120 + QUAD $0xa7c5ac471b478423 // .quad -6357485877563259869 + QUAD $0x0fcf80dc33721d54 // .quad 1139270913992301908 + QUAD $0xd1b71758e219652b // .quad -3335171328526686933 + QUAD $0xd3c36113404ea4a9 // .quad -3187597375937010519 + QUAD $0x83126e978d4fdf3b // .quad -9002011107970261189 + QUAD $0x645a1cac083126ea // .quad 7231123676894144234 + QUAD $0xa3d70a3d70a3d70a // .quad -6640827866535438582 + QUAD $0x3d70a3d70a3d70a4 // .quad 4427218577690292388 + QUAD $0xcccccccccccccccc // .quad -3689348814741910324 + QUAD $0xcccccccccccccccd // .quad -3689348814741910323 + QUAD $0x8000000000000000 // .quad -9223372036854775808 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa000000000000000 // .quad -6917529027641081856 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc800000000000000 // .quad -4035225266123964416 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xfa00000000000000 // .quad -432345564227567616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9c40000000000000 // .quad -7187745005283311616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xc350000000000000 // .quad -4372995238176751616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xf424000000000000 // .quad -854558029293551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9896800000000000 // .quad -7451627795949551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xbebc200000000000 // .quad -4702848726509551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xee6b280000000000 // .quad -1266874889709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9502f90000000000 // .quad -7709325833709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xba43b74000000000 // .quad -5024971273709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe8d4a51000000000 // .quad -1669528073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x9184e72a00000000 // .quad -7960984073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb5e620f480000000 // .quad -5339544073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xe35fa931a0000000 // .quad -2062744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x8ac7230489e80000 // .quad -8446744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x878678326eac9000 // .quad -8681119073709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa968163f0a57b400 // .quad -6239712823709551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x84595161401484a0 // .quad -8910000909647051616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366 + QUAD $0x0000000000000000 // .quad 0 + QUAD $0x813f3978f8940984 // .quad -9133518327554766460 + QUAD $0x4000000000000000 // .quad 4611686018427387904 + QUAD $0xa18f07d736b90be5 // .quad -6805211891016070171 + QUAD $0x5000000000000000 // .quad 5764607523034234880 + QUAD $0xc9f2c9cd04674ede // .quad -3894828845342699810 + QUAD $0xa400000000000000 // .quad -6629298651489370112 + QUAD $0xfc6f7c4045812296 // .quad -256850038250986858 + QUAD $0x4d00000000000000 // .quad 5548434740920451072 + QUAD $0x9dc5ada82b70b59d // .quad -7078060301547948643 + QUAD $0xf020000000000000 // .quad -1143914305352105984 + QUAD $0xc5371912364ce305 // .quad -4235889358507547899 + QUAD $0x6c28000000000000 // .quad 7793479155164643328 + QUAD $0xf684df56c3e01bc6 // .quad -683175679707046970 + QUAD $0xc732000000000000 // .quad -4093209111326359552 + QUAD $0x9a130b963a6c115c // .quad -7344513827457986212 + QUAD $0x3c7f400000000000 // .quad 4359273333062107136 + QUAD $0xc097ce7bc90715b3 // .quad -4568956265895094861 + QUAD $0x4b9f100000000000 // .quad 5449091666327633920 + QUAD $0xf0bdc21abb48db20 // .quad -1099509313941480672 + QUAD $0x1e86d40000000000 // .quad 2199678564482154496 + QUAD $0x96769950b50d88f4 // .quad -7604722348854507276 + QUAD $0x1314448000000000 // .quad 1374799102801346560 + QUAD $0xbc143fa4e250eb31 // .quad -4894216917640746191 + QUAD $0x17d955a000000000 // .quad 1718498878501683200 + QUAD $0xeb194f8e1ae525fd // .quad -1506085128623544835 + QUAD $0x5dcfab0800000000 // .quad 6759809616554491904 + QUAD $0x92efd1b8d0cf37be // .quad -7858832233030797378 + QUAD $0x5aa1cae500000000 // .quad 6530724019560251392 + QUAD $0xb7abc627050305ad // .quad -5211854272861108819 + QUAD $0xf14a3d9e40000000 // .quad -1059967012404461568 + QUAD $0xe596b7b0c643c719 // .quad -1903131822648998119 + QUAD $0x6d9ccd05d0000000 // .quad 7898413271349198848 + QUAD $0x8f7e32ce7bea5c6f // .quad -8106986416796705681 + QUAD $0xe4820023a2000000 // .quad -1981020733047832576 + QUAD $0xb35dbf821ae4f38b // .quad -5522047002568494197 + QUAD $0xdda2802c8a800000 // .quad -2476275916309790720 + QUAD $0xe0352f62a19e306e // .quad -2290872734783229842 + QUAD $0xd50b2037ad200000 // .quad -3095344895387238400 + QUAD $0x8c213d9da502de45 // .quad -8349324486880600507 + QUAD $0x4526f422cc340000 // .quad 4982938468024057856 + QUAD $0xaf298d050e4395d6 // .quad -5824969590173362730 + QUAD $0x9670b12b7f410000 // .quad -7606384970252091392 + QUAD $0xdaf3f04651d47b4c // .quad -2669525969289315508 + QUAD $0x3c0cdd765f114000 // .quad 4327076842467049472 + QUAD $0x88d8762bf324cd0f // .quad -8585982758446904049 + QUAD $0xa5880a69fb6ac800 // .quad -6518949010312869888 + QUAD $0xab0e93b6efee0053 // .quad -6120792429631242157 + QUAD $0x8eea0d047a457a00 // .quad -8148686262891087360 + QUAD $0xd5d238a4abe98068 // .quad -3039304518611664792 + QUAD $0x72a4904598d6d880 // .quad 8260886245095692416 + QUAD $0x85a36366eb71f041 // .quad -8817094351773372351 + QUAD $0x47a6da2b7f864750 // .quad 5163053903184807760 + QUAD $0xa70c3c40a64e6c51 // .quad -6409681921289327535 + QUAD $0x999090b65f67d924 // .quad -7381240676301154012 + QUAD $0xd0cf4b50cfe20765 // .quad -3400416383184271515 + QUAD $0xfff4b4e3f741cf6d // .quad -3178808521666707 + QUAD $0x82818f1281ed449f // .quad -9042789267131251553 + QUAD $0xbff8f10e7a8921a5 // .quad -4613672773753429595 + QUAD $0xa321f2d7226895c7 // .quad -6691800565486676537 + QUAD $0xaff72d52192b6a0e // .quad -5767090967191786994 + QUAD $0xcbea6f8ceb02bb39 // .quad -3753064688430957767 + QUAD $0x9bf4f8a69f764491 // .quad -7208863708989733743 + QUAD $0xfee50b7025c36a08 // .quad -79644842111309304 + QUAD $0x02f236d04753d5b5 // .quad 212292400617608629 + QUAD $0x9f4f2726179a2245 // .quad -6967307053960650171 + QUAD $0x01d762422c946591 // .quad 132682750386005393 + QUAD $0xc722f0ef9d80aad6 // .quad -4097447799023424810 + QUAD $0x424d3ad2b7b97ef6 // .quad 4777539456409894646 + QUAD $0xf8ebad2b84e0d58b // .quad -510123730351893109 + QUAD $0xd2e0898765a7deb3 // .quad -3251447716342407501 + QUAD $0x9b934c3b330c8577 // .quad -7236356359111015049 + QUAD $0x63cc55f49f88eb30 // .quad 7191217214140771120 + QUAD $0xc2781f49ffcfa6d5 // .quad -4433759430461380907 + QUAD $0x3cbf6b71c76b25fc // .quad 4377335499248575996 + QUAD $0xf316271c7fc3908a // .quad -930513269649338230 + QUAD $0x8bef464e3945ef7b // .quad -8363388681221443717 + QUAD $0x97edd871cfda3a56 // .quad -7499099821171918250 + QUAD $0x97758bf0e3cbb5ad // .quad -7532960934977096275 + QUAD $0xbde94e8e43d0c8ec // .quad -4762188758037509908 + QUAD $0x3d52eeed1cbea318 // .quad 4418856886560793368 + QUAD $0xed63a231d4c4fb27 // .quad -1341049929119499481 + QUAD $0x4ca7aaa863ee4bde // .quad 5523571108200991710 + QUAD $0x945e455f24fb1cf8 // .quad -7755685233340769032 + QUAD $0x8fe8caa93e74ef6b // .quad -8076983103442849941 + QUAD $0xb975d6b6ee39e436 // .quad -5082920523248573386 + QUAD $0xb3e2fd538e122b45 // .quad -5484542860876174523 + QUAD $0xe7d34c64a9c85d44 // .quad -1741964635633328828 + QUAD $0x60dbbca87196b617 // .quad 6979379479186945559 + QUAD $0x90e40fbeea1d3a4a // .quad -8006256924911912374 + QUAD $0xbc8955e946fe31ce // .quad -4861259862362934834 + QUAD $0xb51d13aea4a488dd // .quad -5396135137712502563 + QUAD $0x6babab6398bdbe42 // .quad 7758483227328495170 + QUAD $0xe264589a4dcdab14 // .quad -2133482903713240300 + QUAD $0xc696963c7eed2dd2 // .quad -4136954021121544750 + QUAD $0x8d7eb76070a08aec // .quad -8250955842461857044 + QUAD $0xfc1e1de5cf543ca3 // .quad -279753253987271517 + QUAD $0xb0de65388cc8ada8 // .quad -5702008784649933400 + QUAD $0x3b25a55f43294bcc // .quad 4261994450943298508 + QUAD $0xdd15fe86affad912 // .quad -2515824962385028846 + QUAD $0x49ef0eb713f39ebf // .quad 5327493063679123135 + QUAD $0x8a2dbf142dfcc7ab // .quad -8489919629131724885 + QUAD $0x6e3569326c784338 // .quad 7941369183226839864 + QUAD $0xacb92ed9397bf996 // .quad -6000713517987268202 + QUAD $0x49c2c37f07965405 // .quad 5315025460606161925 + QUAD $0xd7e77a8f87daf7fb // .quad -2889205879056697349 + QUAD $0xdc33745ec97be907 // .quad -2579590211097073401 + QUAD $0x86f0ac99b4e8dafd // .quad -8723282702051517699 + QUAD $0x69a028bb3ded71a4 // .quad 7611128154919104932 + QUAD $0xa8acd7c0222311bc // .quad -6292417359137009220 + QUAD $0xc40832ea0d68ce0d // .quad -4321147861633282547 + QUAD $0xd2d80db02aabd62b // .quad -3253835680493873621 + QUAD $0xf50a3fa490c30191 // .quad -789748808614215279 + QUAD $0x83c7088e1aab65db // .quad -8951176327949752869 + QUAD $0x792667c6da79e0fb // .quad 8729779031470891259 + QUAD $0xa4b8cab1a1563f52 // .quad -6577284391509803182 + QUAD $0x577001b891185939 // .quad 6300537770911226169 + QUAD $0xcde6fd5e09abcf26 // .quad -3609919470959866074 + QUAD $0xed4c0226b55e6f87 // .quad -1347699823215743097 + QUAD $0x80b05e5ac60b6178 // .quad -9173728696990998152 + QUAD $0x544f8158315b05b5 // .quad 6075216638131242421 + QUAD $0xa0dc75f1778e39d6 // .quad -6855474852811359786 + QUAD $0x696361ae3db1c722 // .quad 7594020797664053026 + QUAD $0xc913936dd571c84c // .quad -3957657547586811828 + QUAD $0x03bc3a19cd1e38ea // .quad 269153960225290474 + QUAD $0xfb5878494ace3a5f // .quad -335385916056126881 + QUAD $0x04ab48a04065c724 // .quad 336442450281613092 + QUAD $0x9d174b2dcec0e47b // .quad -7127145225176161157 + QUAD $0x62eb0d64283f9c77 // .quad 7127805559067090039 + QUAD $0xc45d1df942711d9a // .quad -4297245513042813542 + QUAD $0x3ba5d0bd324f8395 // .quad 4298070930406474645 + QUAD $0xf5746577930d6500 // .quad -759870872876129024 + QUAD $0xca8f44ec7ee3647a // .quad -3850783373846682502 + QUAD $0x9968bf6abbe85f20 // .quad -7392448323188662496 + QUAD $0x7e998b13cf4e1ecc // .quad 9122475437414293196 + QUAD $0xbfc2ef456ae276e8 // .quad -4628874385558440216 + QUAD $0x9e3fedd8c321a67f // .quad -7043649776941685121 + QUAD $0xefb3ab16c59b14a2 // .quad -1174406963520662366 + QUAD $0xc5cfe94ef3ea101f // .quad -4192876202749718497 + QUAD $0x95d04aee3b80ece5 // .quad -7651533379841495835 + QUAD $0xbba1f1d158724a13 // .quad -4926390635932268013 + QUAD $0xbb445da9ca61281f // .quad -4952730706374481889 + QUAD $0x2a8a6e45ae8edc98 // .quad 3065383741939440792 + QUAD $0xea1575143cf97226 // .quad -1579227364540714458 + QUAD $0xf52d09d71a3293be // .quad -779956341003086914 + QUAD $0x924d692ca61be758 // .quad -7904546130479028392 + QUAD $0x593c2626705f9c57 // .quad 6430056314514152535 + QUAD $0xb6e0c377cfa2e12e // .quad -5268996644671397586 + QUAD $0x6f8b2fb00c77836d // .quad 8037570393142690669 + QUAD $0xe498f455c38b997a // .quad -1974559787411859078 + QUAD $0x0b6dfb9c0f956448 // .quad 823590954573587528 + QUAD $0x8edf98b59a373fec // .quad -8151628894773493780 + QUAD $0x4724bd4189bd5ead // .quad 5126430365035880109 + QUAD $0xb2977ee300c50fe7 // .quad -5577850100039479321 + QUAD $0x58edec91ec2cb658 // .quad 6408037956294850136 + QUAD $0xdf3d5e9bc0f653e1 // .quad -2360626606621961247 + QUAD $0x2f2967b66737e3ee // .quad 3398361426941174766 + QUAD $0x8b865b215899f46c // .quad -8392920656779807636 + QUAD $0xbd79e0d20082ee75 // .quad -4793553135802847627 + QUAD $0xae67f1e9aec07187 // .quad -5879464802547371641 + QUAD $0xecd8590680a3aa12 // .quad -1380255401326171630 + QUAD $0xda01ee641a708de9 // .quad -2737644984756826647 + QUAD $0xe80e6f4820cc9496 // .quad -1725319251657714538 + QUAD $0x884134fe908658b2 // .quad -8628557143114098510 + QUAD $0x3109058d147fdcde // .quad 3533361486141316318 + QUAD $0xaa51823e34a7eede // .quad -6174010410465235234 + QUAD $0xbd4b46f0599fd416 // .quad -4806670179178130410 + QUAD $0xd4e5e2cdc1d1ea96 // .quad -3105826994654156138 + QUAD $0x6c9e18ac7007c91b // .quad 7826720331309500699 + QUAD $0x850fadc09923329e // .quad -8858670899299929442 + QUAD $0x03e2cf6bc604ddb1 // .quad 280014188641050033 + QUAD $0xa6539930bf6bff45 // .quad -6461652605697523899 + QUAD $0x84db8346b786151d // .quad -8873354301053463267 + QUAD $0xcfe87f7cef46ff16 // .quad -3465379738694516970 + QUAD $0xe612641865679a64 // .quad -1868320839462053276 + QUAD $0x81f14fae158c5f6e // .quad -9083391364325154962 + QUAD $0x4fcb7e8f3f60c07f // .quad 5749828502977298559 + QUAD $0xa26da3999aef7749 // .quad -6742553186979055799 + QUAD $0xe3be5e330f38f09e // .quad -2036086408133152610 + QUAD $0xcb090c8001ab551c // .quad -3816505465296431844 + QUAD $0x5cadf5bfd3072cc6 // .quad 6678264026688335046 + QUAD $0xfdcb4fa002162a63 // .quad -158945813193151901 + QUAD $0x73d9732fc7c8f7f7 // .quad 8347830033360418807 + QUAD $0x9e9f11c4014dda7e // .quad -7016870160886801794 + QUAD $0x2867e7fddcdd9afb // .quad 2911550761636567803 + QUAD $0xc646d63501a1511d // .quad -4159401682681114339 + QUAD $0xb281e1fd541501b9 // .quad -5583933584809066055 + QUAD $0xf7d88bc24209a565 // .quad -587566084924005019 + QUAD $0x1f225a7ca91a4227 // .quad 2243455055843443239 + QUAD $0x9ae757596946075f // .quad -7284757830718584993 + QUAD $0x3375788de9b06959 // .quad 3708002419115845977 + QUAD $0xc1a12d2fc3978937 // .quad -4494261269970843337 + QUAD $0x0052d6b1641c83af // .quad 23317005467419567 + QUAD $0xf209787bb47d6b84 // .quad -1006140569036166268 + QUAD $0xc0678c5dbd23a49b // .quad -4582539761593113445 + QUAD $0x9745eb4d50ce6332 // .quad -7546366883288685774 + QUAD $0xf840b7ba963646e1 // .quad -558244341782001951 + QUAD $0xbd176620a501fbff // .quad -4821272585683469313 + QUAD $0xb650e5a93bc3d899 // .quad -5309491445654890343 + QUAD $0xec5d3fa8ce427aff // .quad -1414904713676948737 + QUAD $0xa3e51f138ab4cebf // .quad -6636864307068612929 + QUAD $0x93ba47c980e98cdf // .quad -7801844473689174817 + QUAD $0xc66f336c36b10138 // .quad -4148040191917883080 + QUAD $0xb8a8d9bbe123f017 // .quad -5140619573684080617 + QUAD $0xb80b0047445d4185 // .quad -5185050239897353851 + QUAD $0xe6d3102ad96cec1d // .quad -1814088448677712867 + QUAD $0xa60dc059157491e6 // .quad -6481312799871692314 + QUAD $0x9043ea1ac7e41392 // .quad -8051334308064652398 + QUAD $0x87c89837ad68db30 // .quad -8662506518347195600 + QUAD $0xb454e4a179dd1877 // .quad -5452481866653427593 + QUAD $0x29babe4598c311fc // .quad 3006924907348169212 + QUAD $0xe16a1dc9d8545e94 // .quad -2203916314889396588 + QUAD $0xf4296dd6fef3d67b // .quad -853029884242176389 + QUAD $0x8ce2529e2734bb1d // .quad -8294976724446954723 + QUAD $0x1899e4a65f58660d // .quad 1772699331562333709 + QUAD $0xb01ae745b101e9e4 // .quad -5757034887131305500 + QUAD $0x5ec05dcff72e7f90 // .quad 6827560182880305040 + QUAD $0xdc21a1171d42645d // .quad -2584607590486743971 + QUAD $0x76707543f4fa1f74 // .quad 8534450228600381300 + QUAD $0x899504ae72497eba // .quad -8532908771695296838 + QUAD $0x6a06494a791c53a9 // .quad 7639874402088932265 + QUAD $0xabfa45da0edbde69 // .quad -6054449946191733143 + QUAD $0x0487db9d17636893 // .quad 326470965756389523 + QUAD $0xd6f8d7509292d603 // .quad -2956376414312278525 + QUAD $0x45a9d2845d3c42b7 // .quad 5019774725622874807 + QUAD $0x865b86925b9bc5c2 // .quad -8765264286586255934 + QUAD $0x0b8a2392ba45a9b3 // .quad 831516194300602803 + QUAD $0xa7f26836f282b732 // .quad -6344894339805432014 + QUAD $0x8e6cac7768d7141f // .quad -8183976793979022305 + QUAD $0xd1ef0244af2364ff // .quad -3319431906329402113 + QUAD $0x3207d795430cd927 // .quad 3605087062808385831 + QUAD $0x8335616aed761f1f // .quad -8992173969096958177 + QUAD $0x7f44e6bd49e807b9 // .quad 9170708441896323001 + QUAD $0xa402b9c5a8d3a6e7 // .quad -6628531442943809817 + QUAD $0x5f16206c9c6209a7 // .quad 6851699533943015847 + QUAD $0xcd036837130890a1 // .quad -3673978285252374367 + QUAD $0x36dba887c37a8c10 // .quad 3952938399001381904 + QUAD $0x802221226be55a64 // .quad -9213765455923815836 + QUAD $0xc2494954da2c978a // .quad -4446942528265218166 + QUAD $0xa02aa96b06deb0fd // .quad -6905520801477381891 + QUAD $0xf2db9baa10b7bd6d // .quad -946992141904134803 + QUAD $0xc83553c5c8965d3d // .quad -4020214983419339459 + QUAD $0x6f92829494e5acc8 // .quad 8039631859474607304 + QUAD $0xfa42a8b73abbf48c // .quad -413582710846786420 + QUAD $0xcb772339ba1f17fa // .quad -3785518230938904582 + QUAD $0x9c69a97284b578d7 // .quad -7176018221920323369 + QUAD $0xff2a760414536efc // .quad -60105885123121412 + QUAD $0xc38413cf25e2d70d // .quad -4358336758973016307 + QUAD $0xfef5138519684abb // .quad -75132356403901765 + QUAD $0xf46518c2ef5b8cd1 // .quad -836234930288882479 + QUAD $0x7eb258665fc25d6a // .quad 9129456591349898602 + QUAD $0x98bf2f79d5993802 // .quad -7440175859071633406 + QUAD $0xef2f773ffbd97a62 // .quad -1211618658047395230 + QUAD $0xbeeefb584aff8603 // .quad -4688533805412153853 + QUAD $0xaafb550ffacfd8fb // .quad -6126209340986631941 + QUAD $0xeeaaba2e5dbf6784 // .quad -1248981238337804412 + QUAD $0x95ba2a53f983cf39 // .quad -7657761676233289927 + QUAD $0x952ab45cfa97a0b2 // .quad -7698142301602209614 + QUAD $0xdd945a747bf26184 // .quad -2480258038432112252 + QUAD $0xba756174393d88df // .quad -5010991858575374113 + QUAD $0x94f971119aeef9e5 // .quad -7712008566467528219 + QUAD $0xe912b9d1478ceb17 // .quad -1652053804791829737 + QUAD $0x7a37cd5601aab85e // .quad 8806733365625141342 + QUAD $0x91abb422ccb812ee // .quad -7950062655635975442 + QUAD $0xac62e055c10ab33b // .quad -6025006692552756421 + QUAD $0xb616a12b7fe617aa // .quad -5325892301117581398 + QUAD $0x577b986b314d600a // .quad 6303799689591218186 + QUAD $0xe39c49765fdf9d94 // .quad -2045679357969588844 + QUAD $0xed5a7e85fda0b80c // .quad -1343622424865753076 + QUAD $0x8e41ade9fbebc27d // .quad -8196078626372074883 + QUAD $0x14588f13be847308 // .quad 1466078993672598280 + QUAD $0xb1d219647ae6b31c // .quad -5633412264537705700 + QUAD $0x596eb2d8ae258fc9 // .quad 6444284760518135753 + QUAD $0xde469fbd99a05fe3 // .quad -2430079312244744221 + QUAD $0x6fca5f8ed9aef3bc // .quad 8055355950647669692 + QUAD $0x8aec23d680043bee // .quad -8436328597794046994 + QUAD $0x25de7bb9480d5855 // .quad 2728754459941099605 + QUAD $0xada72ccc20054ae9 // .quad -5933724728815170839 + QUAD $0xaf561aa79a10ae6b // .quad -5812428961928401301 + QUAD $0xd910f7ff28069da4 // .quad -2805469892591575644 + QUAD $0x1b2ba1518094da05 // .quad 1957835834444274181 + QUAD $0x87aa9aff79042286 // .quad -8670947710510816634 + QUAD $0x90fb44d2f05d0843 // .quad -7999724640327104445 + QUAD $0xa99541bf57452b28 // .quad -6226998619711132888 + QUAD $0x353a1607ac744a54 // .quad 3835402254873283156 + QUAD $0xd3fa922f2d1675f2 // .quad -3172062256211528206 + QUAD $0x42889b8997915ce9 // .quad 4794252818591603945 + QUAD $0x847c9b5d7c2e09b7 // .quad -8900067937773286985 + QUAD $0x69956135febada12 // .quad 7608094030047140370 + QUAD $0xa59bc234db398c25 // .quad -6513398903789220827 + QUAD $0x43fab9837e699096 // .quad 4898431519131537558 + QUAD $0xcf02b2c21207ef2e // .quad -3530062611309138130 + QUAD $0x94f967e45e03f4bc // .quad -7712018656367741764 + QUAD $0x8161afb94b44f57d // .quad -9123818159709293187 + QUAD $0x1d1be0eebac278f6 // .quad 2097517367411243254 + QUAD $0xa1ba1ba79e1632dc // .quad -6793086681209228580 + QUAD $0x6462d92a69731733 // .quad 7233582727691441971 + QUAD $0xca28a291859bbf93 // .quad -3879672333084147821 + QUAD $0x7d7b8f7503cfdcff // .quad 9041978409614302463 + QUAD $0xfcb2cb35e702af78 // .quad -237904397927796872 + QUAD $0x5cda735244c3d43f // .quad 6690786993590490175 + QUAD $0x9defbf01b061adab // .quad -7066219276345954901 + QUAD $0x3a0888136afa64a8 // .quad 4181741870994056360 + QUAD $0xc56baec21c7a1916 // .quad -4221088077005055722 + QUAD $0x088aaa1845b8fdd1 // .quad 615491320315182545 + QUAD $0xf6c69a72a3989f5b // .quad -664674077828931749 + QUAD $0x8aad549e57273d46 // .quad -8454007886460797626 + QUAD $0x9a3c2087a63f6399 // .quad -7332950326284164199 + QUAD $0x36ac54e2f678864c // .quad 3939617107816777292 + QUAD $0xc0cb28a98fcf3c7f // .quad -4554501889427817345 + QUAD $0x84576a1bb416a7de // .quad -8910536670511192098 + QUAD $0xf0fdf2d3f3c30b9f // .quad -1081441343357383777 + QUAD $0x656d44a2a11c51d6 // .quad 7308573235570561494 + QUAD $0x969eb7c47859e743 // .quad -7593429867239446717 + QUAD $0x9f644ae5a4b1b326 // .quad -6961356773836868826 + QUAD $0xbc4665b596706114 // .quad -4880101315621920492 + QUAD $0x873d5d9f0dde1fef // .quad -8701695967296086033 + QUAD $0xeb57ff22fc0c7959 // .quad -1488440626100012711 + QUAD $0xa90cb506d155a7eb // .quad -6265433940692719637 + QUAD $0x9316ff75dd87cbd8 // .quad -7847804418953589800 + QUAD $0x09a7f12442d588f3 // .quad 695789805494438131 + QUAD $0xb7dcbf5354e9bece // .quad -5198069505264599346 + QUAD $0x0c11ed6d538aeb30 // .quad 869737256868047664 + QUAD $0xe5d3ef282a242e81 // .quad -1885900863153361279 + QUAD $0x8f1668c8a86da5fb // .quad -8136200465769716229 + QUAD $0x8fa475791a569d10 // .quad -8096217067111932656 + QUAD $0xf96e017d694487bd // .quad -473439272678684739 + QUAD $0xb38d92d760ec4455 // .quad -5508585315462527915 + QUAD $0x37c981dcc395a9ad // .quad 4019886927579031981 + QUAD $0xe070f78d3927556a // .quad -2274045625900771990 + QUAD $0x85bbe253f47b1418 // .quad -8810199395808373736 + QUAD $0x8c469ab843b89562 // .quad -8338807543829064350 + QUAD $0x93956d7478ccec8f // .quad -7812217631593927537 + QUAD $0xaf58416654a6babb // .quad -5811823411358942533 + QUAD $0x387ac8d1970027b3 // .quad 4069786015789754291 + QUAD $0xdb2e51bfe9d0696a // .quad -2653093245771290262 + QUAD $0x06997b05fcc0319f // .quad 475546501309804959 + QUAD $0x88fcf317f22241e2 // .quad -8575712306248138270 + QUAD $0x441fece3bdf81f04 // .quad 4908902581746016004 + QUAD $0xab3c2fddeeaad25a // .quad -6107954364382784934 + QUAD $0xd527e81cad7626c4 // .quad -3087243809672255804 + QUAD $0xd60b3bd56a5586f1 // .quad -3023256937051093263 + QUAD $0x8a71e223d8d3b075 // .quad -8470740780517707659 + QUAD $0x85c7056562757456 // .quad -8807064613298015146 + QUAD $0xf6872d5667844e4a // .quad -682526969396179382 + QUAD $0xa738c6bebb12d16c // .quad -6397144748195131028 + QUAD $0xb428f8ac016561dc // .quad -5464844730172612132 + QUAD $0xd106f86e69d785c7 // .quad -3384744916816525881 + QUAD $0xe13336d701beba53 // .quad -2219369894288377261 + QUAD $0x82a45b450226b39c // .quad -9032994600651410532 + QUAD $0xecc0024661173474 // .quad -1387106183930235788 + QUAD $0xa34d721642b06084 // .quad -6679557232386875260 + QUAD $0x27f002d7f95d0191 // .quad 2877803288514593169 + QUAD $0xcc20ce9bd35c78a5 // .quad -3737760522056206171 + QUAD $0x31ec038df7b441f5 // .quad 3597254110643241461 + QUAD $0xff290242c83396ce // .quad -60514634142869810 + QUAD $0x7e67047175a15272 // .quad 9108253656731439730 + QUAD $0x9f79a169bd203e41 // .quad -6955350673980375487 + QUAD $0x0f0062c6e984d387 // .quad 1080972517029761927 + QUAD $0xc75809c42c684dd1 // .quad -4082502324048081455 + QUAD $0x52c07b78a3e60869 // .quad 5962901664714590313 + QUAD $0xf92e0c3537826145 // .quad -491441886632713915 + QUAD $0xa7709a56ccdf8a83 // .quad -6381430974388925821 + QUAD $0x9bbcc7a142b17ccb // .quad -7224680206786528053 + QUAD $0x88a66076400bb692 // .quad -8600080377420466542 + QUAD $0xc2abf989935ddbfe // .quad -4419164240055772162 + QUAD $0x6acff893d00ea436 // .quad 7696643601933968438 + QUAD $0xf356f7ebf83552fe // .quad -912269281642327298 + QUAD $0x0583f6b8c4124d44 // .quad 397432465562684740 + QUAD $0x98165af37b2153de // .quad -7487697328667536418 + QUAD $0xc3727a337a8b704b // .quad -4363290727450709941 + QUAD $0xbe1bf1b059e9a8d6 // .quad -4747935642407032618 + QUAD $0x744f18c0592e4c5d // .quad 8380944645968776285 + QUAD $0xeda2ee1c7064130c // .quad -1323233534581402868 + QUAD $0x1162def06f79df74 // .quad 1252808770606194548 + QUAD $0x9485d4d1c63e8be7 // .quad -7744549986754458649 + QUAD $0x8addcb5645ac2ba9 // .quad -8440366555225904215 + QUAD $0xb9a74a0637ce2ee1 // .quad -5069001465015685407 + QUAD $0x6d953e2bd7173693 // .quad 7896285879677171347 + QUAD $0xe8111c87c5c1ba99 // .quad -1724565812842218855 + QUAD $0xc8fa8db6ccdd0438 // .quad -3964700705685699528 + QUAD $0x910ab1d4db9914a0 // .quad -7995382660667468640 + QUAD $0x1d9c9892400a22a3 // .quad 2133748077373825699 + QUAD $0xb54d5e4a127f59c8 // .quad -5382542307406947896 + QUAD $0x2503beb6d00cab4c // .quad 2667185096717282124 + QUAD $0xe2a0b5dc971f303a // .quad -2116491865831296966 + QUAD $0x2e44ae64840fd61e // .quad 3333981370896602654 + QUAD $0x8da471a9de737e24 // .quad -8240336443785642460 + QUAD $0x5ceaecfed289e5d3 // .quad 6695424375237764563 + QUAD $0xb10d8e1456105dad // .quad -5688734536304665171 + QUAD $0x7425a83e872c5f48 // .quad 8369280469047205704 + QUAD $0xdd50f1996b947518 // .quad -2499232151953443560 + QUAD $0xd12f124e28f7771a // .quad -3373457468973156582 + QUAD $0x8a5296ffe33cc92f // .quad -8479549122611984081 + QUAD $0x82bd6b70d99aaa70 // .quad -9025939945749304720 + QUAD $0xace73cbfdc0bfb7b // .quad -5987750384837592197 + QUAD $0x636cc64d1001550c // .quad 7164319141522920716 + QUAD $0xd8210befd30efa5a // .quad -2873001962619602342 + QUAD $0x3c47f7e05401aa4f // .quad 4343712908476262991 + QUAD $0x8714a775e3e95c78 // .quad -8713155254278333320 + QUAD $0x65acfaec34810a72 // .quad 7326506586225052274 + QUAD $0xa8d9d1535ce3b396 // .quad -6279758049420528746 + QUAD $0x7f1839a741a14d0e // .quad 9158133232781315342 + QUAD $0xd31045a8341ca07c // .quad -3238011543348273028 + QUAD $0x1ede48111209a051 // .quad 2224294504121868369 + QUAD $0x83ea2b892091e44d // .quad -8941286242233752499 + QUAD $0x934aed0aab460433 // .quad -7833187971778608077 + QUAD $0xa4e4b66b68b65d60 // .quad -6564921784364802720 + QUAD $0xf81da84d56178540 // .quad -568112927868484288 + QUAD $0xce1de40642e3f4b9 // .quad -3594466212028615495 + QUAD $0x36251260ab9d668f // .quad 3901544858591782543 + QUAD $0x80d2ae83e9ce78f3 // .quad -9164070410158966541 + QUAD $0xc1d72b7c6b42601a // .quad -4479063491021217766 + QUAD $0xa1075a24e4421730 // .quad -6843401994271320272 + QUAD $0xb24cf65b8612f820 // .quad -5598829363776522208 + QUAD $0xc94930ae1d529cfc // .quad -3942566474411762436 + QUAD $0xdee033f26797b628 // .quad -2386850686293264856 + QUAD $0xfb9b7cd9a4a7443c // .quad -316522074587315140 + QUAD $0x169840ef017da3b2 // .quad 1628122660560806834 + QUAD $0x9d412e0806e88aa5 // .quad -7115355324258153819 + QUAD $0x8e1f289560ee864f // .quad -8205795374004271537 + QUAD $0xc491798a08a2ad4e // .quad -4282508136895304370 + QUAD $0xf1a6f2bab92a27e3 // .quad -1033872180650563613 + QUAD $0xf5b5d7ec8acb58a2 // .quad -741449152691742558 + QUAD $0xae10af696774b1dc // .quad -5904026244240592420 + QUAD $0x9991a6f3d6bf1765 // .quad -7380934748073420955 + QUAD $0xacca6da1e0a8ef2a // .quad -5995859411864064214 + QUAD $0xbff610b0cc6edd3f // .quad -4614482416664388289 + QUAD $0x17fd090a58d32af4 // .quad 1728547772024695540 + QUAD $0xeff394dcff8a948e // .quad -1156417002403097458 + QUAD $0xddfc4b4cef07f5b1 // .quad -2451001303396518479 + QUAD $0x95f83d0a1fb69cd9 // .quad -7640289654143017767 + QUAD $0x4abdaf101564f98f // .quad 5385653213018257807 + QUAD $0xbb764c4ca7a4440f // .quad -4938676049251384305 + QUAD $0x9d6d1ad41abe37f2 // .quad -7102991539009341454 + QUAD $0xea53df5fd18d5513 // .quad -1561659043136842477 + QUAD $0x84c86189216dc5ee // .quad -8878739423761676818 + QUAD $0x92746b9be2f8552c // .quad -7893565929601608404 + QUAD $0x32fd3cf5b4e49bb5 // .quad 3674159897003727797 + QUAD $0xb7118682dbb66a77 // .quad -5255271393574622601 + QUAD $0x3fbc8c33221dc2a2 // .quad 4592699871254659746 + QUAD $0xe4d5e82392a40515 // .quad -1957403223540890347 + QUAD $0x0fabaf3feaa5334b // .quad 1129188820640936779 + QUAD $0x8f05b1163ba6832d // .quad -8140906042354138323 + QUAD $0x29cb4d87f2a7400f // .quad 3011586022114279439 + QUAD $0xb2c71d5bca9023f8 // .quad -5564446534515285000 + QUAD $0x743e20e9ef511013 // .quad 8376168546070237203 + QUAD $0xdf78e4b2bd342cf6 // .quad -2343872149716718346 + QUAD $0x914da9246b255417 // .quad -7976533391121755113 + QUAD $0x8bab8eefb6409c1a // .quad -8382449121214030822 + QUAD $0x1ad089b6c2f7548f // .quad 1932195658189984911 + QUAD $0xae9672aba3d0c320 // .quad -5866375383090150624 + QUAD $0xa184ac2473b529b2 // .quad -6808127464117294670 + QUAD $0xda3c0f568cc4f3e8 // .quad -2721283210435300376 + QUAD $0xc9e5d72d90a2741f // .quad -3898473311719230433 + QUAD $0x8865899617fb1871 // .quad -8618331034163144591 + QUAD $0x7e2fa67c7a658893 // .quad 9092669226243950739 + QUAD $0xaa7eebfb9df9de8d // .quad -6161227774276542835 + QUAD $0xddbb901b98feeab8 // .quad -2469221522477225288 + QUAD $0xd51ea6fa85785631 // .quad -3089848699418290639 + QUAD $0x552a74227f3ea566 // .quad 6136845133758244198 + QUAD $0x8533285c936b35de // .quad -8848684464777513506 + QUAD $0xd53a88958f872760 // .quad -3082000819042179232 + QUAD $0xa67ff273b8460356 // .quad -6449169562544503978 + QUAD $0x8a892abaf368f138 // .quad -8464187042230111944 + QUAD $0xd01fef10a657842c // .quad -3449775934753242068 + QUAD $0x2d2b7569b0432d86 // .quad 3254824252494523782 + QUAD $0x8213f56a67f6b29b // .quad -9073638986861858149 + QUAD $0x9c3b29620e29fc74 // .quad -7189106879045698444 + QUAD $0xa298f2c501f45f42 // .quad -6730362715149934782 + QUAD $0x8349f3ba91b47b90 // .quad -8986383598807123056 + QUAD $0xcb3f2f7642717713 // .quad -3801267375510030573 + QUAD $0x241c70a936219a74 // .quad 2602078556773259892 + QUAD $0xfe0efb53d30dd4d7 // .quad -139898200960150313 + QUAD $0xed238cd383aa0111 // .quad -1359087822460813039 + QUAD $0x9ec95d1463e8a506 // .quad -7004965403241175802 + QUAD $0xf4363804324a40ab // .quad -849429889038008149 + QUAD $0xc67bb4597ce2ce48 // .quad -4144520735624081848 + QUAD $0xb143c6053edcd0d6 // .quad -5673473379724898090 + QUAD $0xf81aa16fdc1b81da // .quad -568964901102714406 + QUAD $0xdd94b7868e94050b // .quad -2480155706228734709 + QUAD $0x9b10a4e5e9913128 // .quad -7273132090830278360 + QUAD $0xca7cf2b4191c8327 // .quad -3855940325606653145 + QUAD $0xc1d4ce1f63f57d72 // .quad -4479729095110460046 + QUAD $0xfd1c2f611f63a3f1 // .quad -208239388580928527 + QUAD $0xf24a01a73cf2dccf // .quad -987975350460687153 + QUAD $0xbc633b39673c8ced // .quad -4871985254153548563 + QUAD $0x976e41088617ca01 // .quad -7535013621679011327 + QUAD $0xd5be0503e085d814 // .quad -3044990783845967852 + QUAD $0xbd49d14aa79dbc82 // .quad -4807081008671376254 + QUAD $0x4b2d8644d8a74e19 // .quad 5417133557047315993 + QUAD $0xec9c459d51852ba2 // .quad -1397165242411832414 + QUAD $0xddf8e7d60ed1219f // .quad -2451955090545630817 + QUAD $0x93e1ab8252f33b45 // .quad -7790757304148477115 + QUAD $0xcabb90e5c942b504 // .quad -3838314940804713212 + QUAD $0xb8da1662e7b00a17 // .quad -5126760611758208489 + QUAD $0x3d6a751f3b936244 // .quad 4425478360848884292 + QUAD $0xe7109bfba19c0c9d // .quad -1796764746270372707 + QUAD $0x0cc512670a783ad5 // .quad 920161932633717461 + QUAD $0x906a617d450187e2 // .quad -8040506994060064798 + QUAD $0x27fb2b80668b24c6 // .quad 2880944217109767366 + QUAD $0xb484f9dc9641e9da // .quad -5438947724147693094 + QUAD $0xb1f9f660802dedf7 // .quad -5622191765467566601 + QUAD $0xe1a63853bbd26451 // .quad -2186998636757228463 + QUAD $0x5e7873f8a0396974 // .quad 6807318348447705460 + QUAD $0x8d07e33455637eb2 // .quad -8284403175614349646 + QUAD $0xdb0b487b6423e1e9 // .quad -2662955059861265943 + QUAD $0xb049dc016abc5e5f // .quad -5743817951090549153 + QUAD $0x91ce1a9a3d2cda63 // .quad -7940379843253970333 + QUAD $0xdc5c5301c56b75f7 // .quad -2568086420435798537 + QUAD $0x7641a140cc7810fc // .quad 8521269269642088700 + QUAD $0x89b9b3e11b6329ba // .quad -8522583040413455942 + QUAD $0xa9e904c87fcb0a9e // .quad -6203421752542164322 + QUAD $0xac2820d9623bf429 // .quad -6041542782089432023 + QUAD $0x546345fa9fbdcd45 // .quad 6080780864604458309 + QUAD $0xd732290fbacaf133 // .quad -2940242459184402125 + QUAD $0xa97c177947ad4096 // .quad -6234081974526590826 + QUAD $0x867f59a9d4bed6c0 // .quad -8755180564631333184 + QUAD $0x49ed8eabcccc485e // .quad 5327070802775656542 + QUAD $0xa81f301449ee8c70 // .quad -6332289687361778576 + QUAD $0x5c68f256bfff5a75 // .quad 6658838503469570677 + QUAD $0xd226fc195c6a2f8c // .quad -3303676090774835316 + QUAD $0x73832eec6fff3112 // .quad 8323548129336963346 + QUAD $0x83585d8fd9c25db7 // .quad -8982326584375353929 + QUAD $0xc831fd53c5ff7eac // .quad -4021154456019173716 + QUAD $0xa42e74f3d032f525 // .quad -6616222212041804507 + QUAD $0xba3e7ca8b77f5e56 // .quad -5026443070023967146 + QUAD $0xcd3a1230c43fb26f // .quad -3658591746624867729 + QUAD $0x28ce1bd2e55f35ec // .quad 2940318199324816876 + QUAD $0x80444b5e7aa7cf85 // .quad -9204148869281624187 + QUAD $0x7980d163cf5b81b4 // .quad 8755227902219092404 + QUAD $0xa0555e361951c366 // .quad -6893500068174642330 + QUAD $0xd7e105bcc3326220 // .quad -2891023177508298208 + QUAD $0xc86ab5c39fa63440 // .quad -4005189066790915008 + QUAD $0x8dd9472bf3fefaa8 // .quad -8225464990312760664 + QUAD $0xfa856334878fc150 // .quad -394800315061255856 + QUAD $0xb14f98f6f0feb952 // .quad -5670145219463562926 + QUAD $0x9c935e00d4b9d8d2 // .quad -7164279224554366766 + QUAD $0x6ed1bf9a569f33d4 // .quad 7985374283903742932 + QUAD $0xc3b8358109e84f07 // .quad -4343663012265570553 + QUAD $0x0a862f80ec4700c9 // .quad 758345818024902857 + QUAD $0xf4a642e14c6262c8 // .quad -817892746904575288 + QUAD $0xcd27bb612758c0fb // .quad -3663753745896259333 + QUAD $0x98e7e9cccfbd7dbd // .quad -7428711994456441411 + QUAD $0x8038d51cb897789d // .quad -9207375118826243939 + QUAD $0xbf21e44003acdd2c // .quad -4674203974643163860 + QUAD $0xe0470a63e6bd56c4 // .quad -2285846861678029116 + QUAD $0xeeea5d5004981478 // .quad -1231068949876566920 + QUAD $0x1858ccfce06cac75 // .quad 1754377441329851509 + QUAD $0x95527a5202df0ccb // .quad -7686947121313936181 + QUAD $0x0f37801e0c43ebc9 // .quad 1096485900831157193 + QUAD $0xbaa718e68396cffd // .quad -4996997883215032323 + QUAD $0xd30560258f54e6bb // .quad -3241078642388441413 + QUAD $0xe950df20247c83fd // .quad -1634561335591402499 + QUAD $0x47c6b82ef32a206a // .quad 5172023733869224042 + QUAD $0x91d28b7416cdd27e // .quad -7939129862385708418 + QUAD $0x4cdc331d57fa5442 // .quad 5538357842881958978 + QUAD $0xb6472e511c81471d // .quad -5312226309554747619 + QUAD $0xe0133fe4adf8e953 // .quad -2300424733252327085 + QUAD $0xe3d8f9e563a198e5 // .quad -2028596868516046619 + QUAD $0x58180fddd97723a7 // .quad 6347841120289366951 + QUAD $0x8e679c2f5e44ff8f // .quad -8185402070463610993 + QUAD $0x570f09eaa7ea7649 // .quad 6273243709394548297 + QUAD $0xb201833b35d63f73 // .quad -5620066569652125837 + QUAD $0x2cd2cc6551e513db // .quad 3229868618315797467 + QUAD $0xde81e40a034bcf4f // .quad -2413397193637769393 + QUAD $0xf8077f7ea65e58d2 // .quad -574350245532641070 + QUAD $0x8b112e86420f6191 // .quad -8425902273664687727 + QUAD $0xfb04afaf27faf783 // .quad -358968903457900669 + QUAD $0xadd57a27d29339f6 // .quad -5920691823653471754 + QUAD $0x79c5db9af1f9b564 // .quad 8774660907532399972 + QUAD $0xd94ad8b1c7380874 // .quad -2789178761139451788 + QUAD $0x18375281ae7822bd // .quad 1744954097560724157 + QUAD $0x87cec76f1c830548 // .quad -8660765753353239224 + QUAD $0x8f2293910d0b15b6 // .quad -8132775725879323210 + QUAD $0xa9c2794ae3a3c69a // .quad -6214271173264161126 + QUAD $0xb2eb3875504ddb23 // .quad -5554283638921766109 + QUAD $0xd433179d9c8cb841 // .quad -3156152948152813503 + QUAD $0x5fa60692a46151ec // .quad 6892203506629956076 + QUAD $0x849feec281d7f328 // .quad -8890124620236590296 + QUAD $0xdbc7c41ba6bcd334 // .quad -2609901835997359308 + QUAD $0xa5c7ea73224deff3 // .quad -6500969756868349965 + QUAD $0x12b9b522906c0801 // .quad 1349308723430688769 + QUAD $0xcf39e50feae16bef // .quad -3514526177658049553 + QUAD $0xd768226b34870a01 // .quad -2925050114139026943 + QUAD $0x81842f29f2cce375 // .quad -9114107888677362827 + QUAD $0xe6a1158300d46641 // .quad -1828156321336891839 + QUAD $0xa1e53af46f801c53 // .quad -6780948842419315629 + QUAD $0x60495ae3c1097fd1 // .quad 6938176635183661009 + QUAD $0xca5e89b18b602368 // .quad -3864500034596756632 + QUAD $0x385bb19cb14bdfc5 // .quad 4061034775552188357 + QUAD $0xfcf62c1dee382c42 // .quad -218939024818557886 + QUAD $0x46729e03dd9ed7b6 // .quad 5076293469440235446 + QUAD $0x9e19db92b4e31ba9 // .quad -7054365918152680535 + QUAD $0x6c07a2c26a8346d2 // .quad 7784369436827535058 + + // .p2align 4, 0x00 +_VecShiftShuffles: + QUAD $0x0706050403020100; QUAD $0x0f0e0d0c0b0a0908 // .ascii 16, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' + QUAD $0x0807060504030201; QUAD $0xff0f0e0d0c0b0a09 // .ascii 16, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff' + QUAD $0x0908070605040302; QUAD $0xffff0f0e0d0c0b0a // .ascii 16, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff' + QUAD $0x0a09080706050403; QUAD $0xffffff0f0e0d0c0b // .ascii 16, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff' + QUAD $0x0b0a090807060504; QUAD $0xffffffff0f0e0d0c // .ascii 16, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff' + QUAD $0x0c0b0a0908070605; QUAD $0xffffffffff0f0e0d // .ascii 16, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff' + QUAD $0x0d0c0b0a09080706; QUAD $0xffffffffffff0f0e // .ascii 16, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff' + QUAD $0x0e0d0c0b0a090807; QUAD $0xffffffffffffff0f // .ascii 16, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff' + QUAD $0x0f0e0d0c0b0a0908; QUAD $0xffffffffffffffff // .ascii 16, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff' + + // .p2align 4, 0x00 +__SingleQuoteTab: + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000030303030755c // .asciz 8, '\\u0000\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000031303030755c // .asciz 8, '\\u0001\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000032303030755c // .asciz 8, '\\u0002\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000033303030755c // .asciz 8, '\\u0003\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000034303030755c // .asciz 8, '\\u0004\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000035303030755c // .asciz 8, '\\u0005\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000036303030755c // .asciz 8, '\\u0006\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000037303030755c // .asciz 8, '\\u0007\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000038303030755c // .asciz 8, '\\u0008\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x000000000000745c // .asciz 8, '\\t\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x0000000000006e5c // .asciz 8, '\\n\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000062303030755c // .asciz 8, '\\u000b\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000063303030755c // .asciz 8, '\\u000c\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x000000000000725c // .asciz 8, '\\r\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000065303030755c // .asciz 8, '\\u000e\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000066303030755c // .asciz 8, '\\u000f\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000030313030755c // .asciz 8, '\\u0010\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000031313030755c // .asciz 8, '\\u0011\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000032313030755c // .asciz 8, '\\u0012\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000033313030755c // .asciz 8, '\\u0013\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000034313030755c // .asciz 8, '\\u0014\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000035313030755c // .asciz 8, '\\u0015\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000036313030755c // .asciz 8, '\\u0016\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000037313030755c // .asciz 8, '\\u0017\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000038313030755c // .asciz 8, '\\u0018\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000039313030755c // .asciz 8, '\\u0019\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000061313030755c // .asciz 8, '\\u001a\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000062313030755c // .asciz 8, '\\u001b\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000063313030755c // .asciz 8, '\\u001c\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000064313030755c // .asciz 8, '\\u001d\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000065313030755c // .asciz 8, '\\u001e\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000066313030755c // .asciz 8, '\\u001f\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x000000000000225c // .asciz 8, '\\"\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000002 // .quad 2 + QUAD $0x0000000000005c5c // .asciz 8, '\\\\\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +__DoubleQuoteTab: + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0030303030755c5c // .asciz 8, '\\\\u0000\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0031303030755c5c // .asciz 8, '\\\\u0001\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0032303030755c5c // .asciz 8, '\\\\u0002\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0033303030755c5c // .asciz 8, '\\\\u0003\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0034303030755c5c // .asciz 8, '\\\\u0004\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0035303030755c5c // .asciz 8, '\\\\u0005\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0036303030755c5c // .asciz 8, '\\\\u0006\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0037303030755c5c // .asciz 8, '\\\\u0007\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0038303030755c5c // .asciz 8, '\\\\u0008\x00' + QUAD $0x0000000000000003 // .quad 3 + QUAD $0x0000000000745c5c // .asciz 8, '\\\\t\x00\x00\x00\x00\x00' + QUAD $0x0000000000000003 // .quad 3 + QUAD $0x00000000006e5c5c // .asciz 8, '\\\\n\x00\x00\x00\x00\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0062303030755c5c // .asciz 8, '\\\\u000b\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0063303030755c5c // .asciz 8, '\\\\u000c\x00' + QUAD $0x0000000000000003 // .quad 3 + QUAD $0x0000000000725c5c // .asciz 8, '\\\\r\x00\x00\x00\x00\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0065303030755c5c // .asciz 8, '\\\\u000e\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0066303030755c5c // .asciz 8, '\\\\u000f\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0030313030755c5c // .asciz 8, '\\\\u0010\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0031313030755c5c // .asciz 8, '\\\\u0011\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0032313030755c5c // .asciz 8, '\\\\u0012\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0033313030755c5c // .asciz 8, '\\\\u0013\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0034313030755c5c // .asciz 8, '\\\\u0014\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0035313030755c5c // .asciz 8, '\\\\u0015\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0036313030755c5c // .asciz 8, '\\\\u0016\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0037313030755c5c // .asciz 8, '\\\\u0017\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0038313030755c5c // .asciz 8, '\\\\u0018\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0039313030755c5c // .asciz 8, '\\\\u0019\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0061313030755c5c // .asciz 8, '\\\\u001a\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0062313030755c5c // .asciz 8, '\\\\u001b\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0063313030755c5c // .asciz 8, '\\\\u001c\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0064313030755c5c // .asciz 8, '\\\\u001d\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0065313030755c5c // .asciz 8, '\\\\u001e\x00' + QUAD $0x0000000000000007 // .quad 7 + QUAD $0x0066313030755c5c // .asciz 8, '\\\\u001f\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000004 // .quad 4 + QUAD $0x00000000225c5c5c // .asciz 8, '\\\\\\"\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000004 // .quad 4 + QUAD $0x000000005c5c5c5c // .asciz 8, '\\\\\\\\\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +__EscTab: + QUAD $0x0101010101010101; QUAD $0x0101010101010101 // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01' + QUAD $0x0101010101010101; QUAD $0x0101010101010101 // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01' + QUAD $0x0000000000010000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x01 // .ascii 13, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x0000; BYTE $0x00 // .space 3, '\x00\x00\x00' + + // .p2align 4, 0x00 +__UnquoteTab: + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000220000; QUAD $0x2f00000000000000 // .ascii 16, '\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000005c00000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00' + QUAD $0x000c000000080000; QUAD $0x000a000000000000 // .ascii 16, '\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00' + LONG $0x000d0000; WORD $0xff09 // .ascii 6, '\x00\x00\r\x00\t\xff' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; WORD $0x0000 // .space 10, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +__HtmlQuoteTab: + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000036323030755c // .asciz 8, '\\u0026\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000063333030755c // .asciz 8, '\\u003c\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000065333030755c // .asciz 8, '\\u003e\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000038323032755c // .asciz 8, '\\u2028\x00\x00' + QUAD $0x0000000000000006 // .quad 6 + QUAD $0x000039323032755c // .asciz 8, '\\u2029\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + + // .p2align 4, 0x00 +_LSHIFT_TAB: + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000 // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000001 // .long 1 + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000001 // .long 1 + QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000001 // .long 1 + QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000002 // .long 2 + QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000002 // .long 2 + QUAD $0x0000000035323133; QUAD $0x0000000000000000 // .asciz 16, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000002 // .long 2 + QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000003 // .long 3 + QUAD $0x0000003532313837; QUAD $0x0000000000000000 // .asciz 16, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000003 // .long 3 + QUAD $0x0000353236303933; QUAD $0x0000000000000000 // .asciz 16, '390625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000003 // .long 3 + QUAD $0x0035323133353931; QUAD $0x0000000000000000 // .asciz 16, '1953125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x0035323635363739; QUAD $0x0000000000000000 // .asciz 16, '9765625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x3532313832383834; QUAD $0x0000000000000000 // .asciz 16, '48828125\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x3236303431343432; QUAD $0x0000000000000035 // .asciz 16, '244140625\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000004 // .long 4 + QUAD $0x3133303730323231; QUAD $0x0000000000003532 // .asciz 16, '1220703125\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000005 // .long 5 + QUAD $0x3635313533303136; QUAD $0x0000000000003532 // .asciz 16, '6103515625\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000005 // .long 5 + QUAD $0x3837353731353033; QUAD $0x0000000000353231 // .asciz 16, '30517578125\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000005 // .long 5 + QUAD $0x3938373835323531; QUAD $0x0000000035323630 // .asciz 16, '152587890625\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000006 // .long 6 + QUAD $0x3534393339323637; QUAD $0x0000000035323133 // .asciz 16, '762939453125\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000006 // .long 6 + QUAD $0x3237393634313833; QUAD $0x0000003532363536 // .asciz 16, '3814697265625\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000006 // .long 6 + QUAD $0x3638343337303931; QUAD $0x0000353231383233 // .asciz 16, '19073486328125\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3133343736333539; QUAD $0x0000353236303436 // .asciz 16, '95367431640625\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3531373338363734; QUAD $0x0035323133303238 // .asciz 16, '476837158203125\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3735383134383332; QUAD $0x3532363531303139 // .asciz 16, '2384185791015625' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000007 // .long 7 + QUAD $0x3832393032393131; QUAD $0x3231383730353539 // .asciz 16, '1192092895507812' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000008 // .long 8 + QUAD $0x3434363430363935; QUAD $0x3236303933353737 // .asciz 16, '5960464477539062' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000008 // .long 8 + QUAD $0x3232333230383932; QUAD $0x3133353936373833 // .asciz 16, '2980232238769531' + QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000008 // .long 8 + QUAD $0x3136313130393431; QUAD $0x3536373438333931 // .asciz 16, '1490116119384765' + QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000009 // .long 9 + QUAD $0x3530383530353437; QUAD $0x3832383332393639 // .asciz 16, '7450580596923828' + QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000009 // .long 9 + QUAD $0x3230393235323733; QUAD $0x3431393136343839 // .asciz 16, '3725290298461914' + QUAD $0x0000000035323630; QUAD $0x0000000000000000 // .asciz 16, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000009 // .long 9 + QUAD $0x3135343632363831; QUAD $0x3735393033323934 // .asciz 16, '1862645149230957' + QUAD $0x0000003532313330; QUAD $0x0000000000000000 // .asciz 16, '03125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3735323233313339; QUAD $0x3538373435313634 // .asciz 16, '9313225746154785' + QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3832313636353634; QUAD $0x3239333737303337 // .asciz 16, '4656612873077392' + QUAD $0x0000353231383735; QUAD $0x0000000000000000 // .asciz 16, '578125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3436303338323332; QUAD $0x3639363833353633 // .asciz 16, '2328306436538696' + QUAD $0x0035323630393832; QUAD $0x0000000000000000 // .asciz 16, '2890625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000a // .long 10 + QUAD $0x3233353134363131; QUAD $0x3834333936323831 // .asciz 16, '1164153218269348' + QUAD $0x3532313335343431; QUAD $0x0000000000000000 // .asciz 16, '14453125\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000b // .long 11 + QUAD $0x3036363730323835; QUAD $0x3034373634333139 // .asciz 16, '5820766091346740' + QUAD $0x3532363536323237; QUAD $0x0000000000000000 // .asciz 16, '72265625\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000b // .long 11 + QUAD $0x3033383330313932; QUAD $0x3037333337363534 // .asciz 16, '2910383045673370' + QUAD $0x3231383233313633; QUAD $0x0000000000000035 // .asciz 16, '361328125\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000b // .long 11 + QUAD $0x3531393135353431; QUAD $0x3538363633383232 // .asciz 16, '1455191522836685' + QUAD $0x3630343636303831; QUAD $0x0000000000003532 // .asciz 16, '1806640625\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000c // .long 12 + QUAD $0x3637353935373237; QUAD $0x3532343338313431 // .asciz 16, '7275957614183425' + QUAD $0x3133303233333039; QUAD $0x0000000000003532 // .asciz 16, '9033203125\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000c // .long 12 + QUAD $0x3838373937333633; QUAD $0x3231373139303730 // .asciz 16, '3637978807091712' + QUAD $0x3531303636313539; QUAD $0x0000000000353236 // .asciz 16, '95166015625\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000c // .long 12 + QUAD $0x3439383938313831; QUAD $0x3635383534353330 // .asciz 16, '1818989403545856' + QUAD $0x3730303338353734; QUAD $0x0000000035323138 // .asciz 16, '475830078125\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3037343934393039; QUAD $0x3238323932373731 // .asciz 16, '9094947017729282' + QUAD $0x3933303531393733; QUAD $0x0000000035323630 // .asciz 16, '379150390625\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3533373437343534; QUAD $0x3134363436383830 // .asciz 16, '4547473508864641' + QUAD $0x3931353735393831; QUAD $0x0000003532313335 // .asciz 16, '1895751953125\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3736333733373232; QUAD $0x3032333233343435 // .asciz 16, '2273736754432320' + QUAD $0x3935373837343935; QUAD $0x0000353236353637 // .asciz 16, '59478759765625\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000d // .long 13 + QUAD $0x3338363836333131; QUAD $0x3036313631323737 // .asciz 16, '1136868377216160' + QUAD $0x3937333933373932; QUAD $0x0035323138323838 // .asciz 16, '297393798828125\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000e // .long 14 + QUAD $0x3831343334383635; QUAD $0x3130383038303638 // .asciz 16, '5684341886080801' + QUAD $0x3939383639363834; QUAD $0x0035323630343134 // .asciz 16, '486968994140625\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000e // .long 14 + QUAD $0x3930373132343832; QUAD $0x3030343034303334 // .asciz 16, '2842170943040400' + QUAD $0x3934343834333437; QUAD $0x3532313330373037 // .asciz 16, '7434844970703125' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000e // .long 14 + QUAD $0x3435383031323431; QUAD $0x3030323032353137 // .asciz 16, '1421085471520200' + QUAD $0x3432323437313733; QUAD $0x3236353135333538 // .asciz 16, '3717422485351562' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000f // .long 15 + QUAD $0x3337323435303137; QUAD $0x3130303130363735 // .asciz 16, '7105427357601001' + QUAD $0x3432313137383538; QUAD $0x3231383735373632 // .asciz 16, '8587112426757812' + QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000f // .long 15 + QUAD $0x3633313732353533; QUAD $0x3030353030383837 // .asciz 16, '3552713678800500' + QUAD $0x3236353533393239; QUAD $0x3630393837333331 // .asciz 16, '9293556213378906' + QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x0000000f // .long 15 + QUAD $0x3836353336373731; QUAD $0x3035323030343933 // .asciz 16, '1776356839400250' + QUAD $0x3138373736343634; QUAD $0x3335343938363630 // .asciz 16, '4646778106689453' + QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3134383731383838; QUAD $0x3235323130303739 // .asciz 16, '8881784197001252' + QUAD $0x3530393833333233; QUAD $0x3536323734343333 // .asciz 16, '3233890533447265' + QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3032393830343434; QUAD $0x3632363030353839 // .asciz 16, '4440892098500626' + QUAD $0x3235343936313631; QUAD $0x3233363332373636 // .asciz 16, '1616945266723632' + QUAD $0x0000000035323138; QUAD $0x0000000000000000 // .asciz 16, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3036343430323232; QUAD $0x3331333035323934 // .asciz 16, '2220446049250313' + QUAD $0x3632373438303830; QUAD $0x3631383136333333 // .asciz 16, '0808472633361816' + QUAD $0x0000003532363034; QUAD $0x0000000000000000 // .asciz 16, '40625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000010 // .long 16 + QUAD $0x3033323230313131; QUAD $0x3635313532363432 // .asciz 16, '1110223024625156' + QUAD $0x3336333234303435; QUAD $0x3830393038363631 // .asciz 16, '5404236316680908' + QUAD $0x0000353231333032; QUAD $0x0000000000000000 // .asciz 16, '203125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000011 // .long 17 + QUAD $0x3135313131353535; QUAD $0x3238373532313332 // .asciz 16, '5551115123125782' + QUAD $0x3531383131323037; QUAD $0x3134353430343338 // .asciz 16, '7021181583404541' + QUAD $0x0000353236353130; QUAD $0x0000000000000000 // .asciz 16, '015625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000011 // .long 17 + QUAD $0x3537353535373732; QUAD $0x3139383236353136 // .asciz 16, '2775557561562891' + QUAD $0x3730393530313533; QUAD $0x3037323230373139 // .asciz 16, '3510590791702270' + QUAD $0x0035323138373035; QUAD $0x0000000000000000 // .asciz 16, '5078125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000011 // .long 17 + QUAD $0x3738373737383331; QUAD $0x3534343138373038 // .asciz 16, '1387778780781445' + QUAD $0x3335393235353736; QUAD $0x3533313135383539 // .asciz 16, '6755295395851135' + QUAD $0x3532363039333532; QUAD $0x0000000000000000 // .asciz 16, '25390625\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000012 // .long 18 + QUAD $0x3933393838333936; QUAD $0x3832323730393330 // .asciz 16, '6938893903907228' + QUAD $0x3936373436373733; QUAD $0x3637363535323937 // .asciz 16, '3776476979255676' + QUAD $0x3532313335393632; QUAD $0x0000000000000000 // .asciz 16, '26953125\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000012 // .long 18 + QUAD $0x3936343439363433; QUAD $0x3431363335393135 // .asciz 16, '3469446951953614' + QUAD $0x3438333238383831; QUAD $0x3833383732363938 // .asciz 16, '1888238489627838' + QUAD $0x3236353637343331; QUAD $0x0000000000000035 // .asciz 16, '134765625\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000012 // .long 18 + QUAD $0x3433323734333731; QUAD $0x3730383637393537 // .asciz 16, '1734723475976807' + QUAD $0x3239313134343930; QUAD $0x3931393331383434 // .asciz 16, '0944119244813919' + QUAD $0x3138323833373630; QUAD $0x0000000000003532 // .asciz 16, '0673828125\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + LONG $0x00000013 // .long 19 + QUAD $0x3337313633373638; QUAD $0x3533303438383937 // .asciz 16, '8673617379884035' + QUAD $0x3236393530323734; QUAD $0x3539353936303432 // .asciz 16, '4720596224069595' + QUAD $0x3630343139363333; QUAD $0x0000000000003532 // .asciz 16, '3369140625\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + LONG $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_P10_TAB: + QUAD $0x3ff0000000000000 // .quad 0x3ff0000000000000 + QUAD $0x4024000000000000 // .quad 0x4024000000000000 + QUAD $0x4059000000000000 // .quad 0x4059000000000000 + QUAD $0x408f400000000000 // .quad 0x408f400000000000 + QUAD $0x40c3880000000000 // .quad 0x40c3880000000000 + QUAD $0x40f86a0000000000 // .quad 0x40f86a0000000000 + QUAD $0x412e848000000000 // .quad 0x412e848000000000 + QUAD $0x416312d000000000 // .quad 0x416312d000000000 + QUAD $0x4197d78400000000 // .quad 0x4197d78400000000 + QUAD $0x41cdcd6500000000 // .quad 0x41cdcd6500000000 + QUAD $0x4202a05f20000000 // .quad 0x4202a05f20000000 + QUAD $0x42374876e8000000 // .quad 0x42374876e8000000 + QUAD $0x426d1a94a2000000 // .quad 0x426d1a94a2000000 + QUAD $0x42a2309ce5400000 // .quad 0x42a2309ce5400000 + QUAD $0x42d6bcc41e900000 // .quad 0x42d6bcc41e900000 + QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000 + QUAD $0x4341c37937e08000 // .quad 0x4341c37937e08000 + QUAD $0x4376345785d8a000 // .quad 0x4376345785d8a000 + QUAD $0x43abc16d674ec800 // .quad 0x43abc16d674ec800 + QUAD $0x43e158e460913d00 // .quad 0x43e158e460913d00 + QUAD $0x4415af1d78b58c40 // .quad 0x4415af1d78b58c40 + QUAD $0x444b1ae4d6e2ef50 // .quad 0x444b1ae4d6e2ef50 + QUAD $0x4480f0cf064dd592 // .quad 0x4480f0cf064dd592 + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +_LB_96b09a0f: // _pow10_ceil_sig_f32.g + QUAD $0x81ceb32c4b43fcf5 // .quad -9093133594791772939 + QUAD $0xa2425ff75e14fc32 // .quad -6754730975062328270 + QUAD $0xcad2f7f5359a3b3f // .quad -3831727700400522433 + QUAD $0xfd87b5f28300ca0e // .quad -177973607073265138 + QUAD $0x9e74d1b791e07e49 // .quad -7028762532061872567 + QUAD $0xc612062576589ddb // .quad -4174267146649952805 + QUAD $0xf79687aed3eec552 // .quad -606147914885053102 + QUAD $0x9abe14cd44753b53 // .quad -7296371474444240045 + QUAD $0xc16d9a0095928a28 // .quad -4508778324627912152 + QUAD $0xf1c90080baf72cb2 // .quad -1024286887357502286 + QUAD $0x971da05074da7bef // .quad -7557708332239520785 + QUAD $0xbce5086492111aeb // .quad -4835449396872013077 + QUAD $0xec1e4a7db69561a6 // .quad -1432625727662628442 + QUAD $0x9392ee8e921d5d08 // .quad -7812920107430224632 + QUAD $0xb877aa3236a4b44a // .quad -5154464115860392886 + QUAD $0xe69594bec44de15c // .quad -1831394126398103204 + QUAD $0x901d7cf73ab0acda // .quad -8062150356639896358 + QUAD $0xb424dc35095cd810 // .quad -5466001927372482544 + QUAD $0xe12e13424bb40e14 // .quad -2220816390788215276 + QUAD $0x8cbccc096f5088cc // .quad -8305539271883716404 + QUAD $0xafebff0bcb24aaff // .quad -5770238071427257601 + QUAD $0xdbe6fecebdedd5bf // .quad -2601111570856684097 + QUAD $0x89705f4136b4a598 // .quad -8543223759426509416 + QUAD $0xabcc77118461cefd // .quad -6067343680855748867 + QUAD $0xd6bf94d5e57a42bd // .quad -2972493582642298179 + QUAD $0x8637bd05af6c69b6 // .quad -8775337516792518218 + QUAD $0xa7c5ac471b478424 // .quad -6357485877563259868 + QUAD $0xd1b71758e219652c // .quad -3335171328526686932 + QUAD $0x83126e978d4fdf3c // .quad -9002011107970261188 + QUAD $0xa3d70a3d70a3d70b // .quad -6640827866535438581 + QUAD $0xcccccccccccccccd // .quad -3689348814741910323 + QUAD $0x8000000000000000 // .quad -9223372036854775808 + QUAD $0xa000000000000000 // .quad -6917529027641081856 + QUAD $0xc800000000000000 // .quad -4035225266123964416 + QUAD $0xfa00000000000000 // .quad -432345564227567616 + QUAD $0x9c40000000000000 // .quad -7187745005283311616 + QUAD $0xc350000000000000 // .quad -4372995238176751616 + QUAD $0xf424000000000000 // .quad -854558029293551616 + QUAD $0x9896800000000000 // .quad -7451627795949551616 + QUAD $0xbebc200000000000 // .quad -4702848726509551616 + QUAD $0xee6b280000000000 // .quad -1266874889709551616 + QUAD $0x9502f90000000000 // .quad -7709325833709551616 + QUAD $0xba43b74000000000 // .quad -5024971273709551616 + QUAD $0xe8d4a51000000000 // .quad -1669528073709551616 + QUAD $0x9184e72a00000000 // .quad -7960984073709551616 + QUAD $0xb5e620f480000000 // .quad -5339544073709551616 + QUAD $0xe35fa931a0000000 // .quad -2062744073709551616 + QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616 + QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616 + QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616 + QUAD $0x8ac7230489e80000 // .quad -8446744073709551616 + QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616 + QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616 + QUAD $0x878678326eac9000 // .quad -8681119073709551616 + QUAD $0xa968163f0a57b400 // .quad -6239712823709551616 + QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616 + QUAD $0x84595161401484a0 // .quad -8910000909647051616 + QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616 + QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366 + QUAD $0x813f3978f8940985 // .quad -9133518327554766459 + QUAD $0xa18f07d736b90be6 // .quad -6805211891016070170 + QUAD $0xc9f2c9cd04674edf // .quad -3894828845342699809 + QUAD $0xfc6f7c4045812297 // .quad -256850038250986857 + QUAD $0x9dc5ada82b70b59e // .quad -7078060301547948642 + QUAD $0xc5371912364ce306 // .quad -4235889358507547898 + QUAD $0xf684df56c3e01bc7 // .quad -683175679707046969 + QUAD $0x9a130b963a6c115d // .quad -7344513827457986211 + QUAD $0xc097ce7bc90715b4 // .quad -4568956265895094860 + QUAD $0xf0bdc21abb48db21 // .quad -1099509313941480671 + QUAD $0x96769950b50d88f5 // .quad -7604722348854507275 + QUAD $0xbc143fa4e250eb32 // .quad -4894216917640746190 + QUAD $0xeb194f8e1ae525fe // .quad -1506085128623544834 + QUAD $0x92efd1b8d0cf37bf // .quad -7858832233030797377 + QUAD $0xb7abc627050305ae // .quad -5211854272861108818 + QUAD $0xe596b7b0c643c71a // .quad -1903131822648998118 + QUAD $0x8f7e32ce7bea5c70 // .quad -8106986416796705680 + QUAD $0xb35dbf821ae4f38c // .quad -5522047002568494196 + +TEXT ·__f32toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -56(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_f32toa: + MOVQ out+0(FP), DI + MOVSD val+8(FP), X0 + CALL ·__native_entry__+28688(SB) // _f32toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__f64toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -80(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_f64toa: + MOVQ out+0(FP), DI + MOVSD val+8(FP), X0 + CALL ·__native_entry__+464(SB) // _f64toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -264(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_get_by_path: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ path+16(FP), DX + CALL ·__native_entry__+26432(SB) // _get_by_path + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__html_escape(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -64(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_html_escape: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ dp+16(FP), DX + MOVQ dn+24(FP), CX + CALL ·__native_entry__+9584(SB) // _html_escape + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__i64toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -16(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_i64toa: + MOVQ out+0(FP), DI + MOVQ val+8(FP), SI + CALL ·__native_entry__+3744(SB) // _i64toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__lspace(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -8(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_lspace: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ off+16(FP), DX + CALL ·__native_entry__+80(SB) // _lspace + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__quote(SB), NOSPLIT | NOFRAME, $0 - 48 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -80(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_quote: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ dp+16(FP), DX + MOVQ dn+24(FP), CX + MOVQ flags+32(FP), R8 + CALL ·__native_entry__+5472(SB) // _quote + MOVQ AX, ret+40(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_array(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_array: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + MOVQ flags+24(FP), CX + CALL ·__native_entry__+19184(SB) // _skip_array + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_number(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -72(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_number: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + CALL ·__native_entry__+22528(SB) // _skip_number + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_object(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_object: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + MOVQ flags+24(FP), CX + CALL ·__native_entry__+21088(SB) // _skip_object + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_one(SB), NOSPLIT | NOFRAME, $0 - 40 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_one: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + MOVQ flags+24(FP), CX + CALL ·__native_entry__+22688(SB) // _skip_one + MOVQ AX, ret+32(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__skip_one_fast(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -160(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_skip_one_fast: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + CALL ·__native_entry__+22912(SB) // _skip_one_fast + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__u64toa(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -8(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_u64toa: + MOVQ out+0(FP), DI + MOVQ val+8(FP), SI + CALL ·__native_entry__+4016(SB) // _u64toa + MOVQ AX, ret+16(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__unquote(SB), NOSPLIT | NOFRAME, $0 - 48 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_unquote: + MOVQ sp+0(FP), DI + MOVQ nb+8(FP), SI + MOVQ dp+16(FP), DX + MOVQ ep+24(FP), CX + MOVQ flags+32(FP), R8 + CALL ·__native_entry__+7184(SB) // _unquote + MOVQ AX, ret+40(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__validate_one(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_validate_one: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + CALL ·__native_entry__+22736(SB) // _validate_one + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__validate_utf8(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -48(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_validate_utf8: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ m+16(FP), DX + CALL ·__native_entry__+27456(SB) // _validate_utf8 + MOVQ AX, ret+24(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__validate_utf8_fast(SB), NOSPLIT | NOFRAME, $0 - 16 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -24(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_validate_utf8_fast: + MOVQ s+0(FP), DI + CALL ·__native_entry__+28128(SB) // _validate_utf8_fast + MOVQ AX, ret+8(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__value(SB), NOSPLIT | NOFRAME, $0 - 48 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -368(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_value: + MOVQ s+0(FP), DI + MOVQ n+8(FP), SI + MOVQ p+16(FP), DX + MOVQ v+24(FP), CX + MOVQ flags+32(FP), R8 + CALL ·__native_entry__+13216(SB) // _value + MOVQ AX, ret+40(FP) + RET + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vnumber(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -280(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vnumber: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + LEAQ ·__native_entry__+16928(SB), AX // _vnumber + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vsigned(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -16(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vsigned: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + LEAQ ·__native_entry__+18464(SB), AX // _vsigned + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vstring(SB), NOSPLIT | NOFRAME, $0 - 32 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -128(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vstring: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + MOVQ flags+24(FP), CX + LEAQ ·__native_entry__+15408(SB), AX // _vstring + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + +TEXT ·__vunsigned(SB), NOSPLIT | NOFRAME, $0 - 24 + NO_LOCAL_POINTERS + +_entry: + MOVQ (TLS), R14 + LEAQ -24(SP), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + +_vunsigned: + MOVQ s+0(FP), DI + MOVQ p+8(FP), SI + MOVQ v+16(FP), DX + LEAQ ·__native_entry__+18816(SB), AX // _vunsigned + JMP AX + +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_export_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/sse/native_export_amd64.go new file mode 100644 index 000000000..898bad431 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_export_amd64.go @@ -0,0 +1,49 @@ +// 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 sse + +var ( + S_f64toa = _subr__f64toa + S_f32toa = _subr__f32toa + S_i64toa = _subr__i64toa + S_u64toa = _subr__u64toa + S_lspace = _subr__lspace +) + +var ( + S_quote = _subr__quote + S_unquote = _subr__unquote +) + +var ( + S_value = _subr__value + S_vstring = _subr__vstring + S_vnumber = _subr__vnumber + S_vsigned = _subr__vsigned + S_vunsigned = _subr__vunsigned +) + +var ( + S_skip_one = _subr__skip_one + S_skip_one_fast = _subr__skip_one_fast + S_skip_array = _subr__skip_array + S_skip_object = _subr__skip_object + S_skip_number = _subr__skip_number + S_get_by_path = _subr__get_by_path +) diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go new file mode 100644 index 000000000..26dee6de2 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go @@ -0,0 +1,109 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package sse + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __native_entry__() uintptr + +var ( + _subr__f32toa = __native_entry__() + 28688 + _subr__f64toa = __native_entry__() + 464 + _subr__get_by_path = __native_entry__() + 26432 + _subr__html_escape = __native_entry__() + 9584 + _subr__i64toa = __native_entry__() + 3744 + _subr__lspace = __native_entry__() + 80 + _subr__quote = __native_entry__() + 5472 + _subr__skip_array = __native_entry__() + 19184 + _subr__skip_number = __native_entry__() + 22528 + _subr__skip_object = __native_entry__() + 21088 + _subr__skip_one = __native_entry__() + 22688 + _subr__skip_one_fast = __native_entry__() + 22912 + _subr__u64toa = __native_entry__() + 4016 + _subr__unquote = __native_entry__() + 7184 + _subr__validate_one = __native_entry__() + 22736 + _subr__validate_utf8 = __native_entry__() + 27456 + _subr__validate_utf8_fast = __native_entry__() + 28128 + _subr__value = __native_entry__() + 13216 + _subr__vnumber = __native_entry__() + 16928 + _subr__vsigned = __native_entry__() + 18464 + _subr__vstring = __native_entry__() + 15408 + _subr__vunsigned = __native_entry__() + 18816 +) + +const ( + _stack__f32toa = 56 + _stack__f64toa = 80 + _stack__get_by_path = 264 + _stack__html_escape = 64 + _stack__i64toa = 16 + _stack__lspace = 8 + _stack__quote = 80 + _stack__skip_array = 128 + _stack__skip_number = 72 + _stack__skip_object = 128 + _stack__skip_one = 128 + _stack__skip_one_fast = 160 + _stack__u64toa = 8 + _stack__unquote = 128 + _stack__validate_one = 128 + _stack__validate_utf8 = 48 + _stack__validate_utf8_fast = 24 + _stack__value = 368 + _stack__vnumber = 280 + _stack__vsigned = 16 + _stack__vstring = 128 + _stack__vunsigned = 24 +) + +var ( + _ = _subr__f32toa + _ = _subr__f64toa + _ = _subr__get_by_path + _ = _subr__html_escape + _ = _subr__i64toa + _ = _subr__lspace + _ = _subr__quote + _ = _subr__skip_array + _ = _subr__skip_number + _ = _subr__skip_object + _ = _subr__skip_one + _ = _subr__skip_one_fast + _ = _subr__u64toa + _ = _subr__unquote + _ = _subr__validate_one + _ = _subr__validate_utf8 + _ = _subr__validate_utf8_fast + _ = _subr__value + _ = _subr__vnumber + _ = _subr__vsigned + _ = _subr__vstring + _ = _subr__vunsigned +) + +const ( + _ = _stack__f32toa + _ = _stack__f64toa + _ = _stack__get_by_path + _ = _stack__html_escape + _ = _stack__i64toa + _ = _stack__lspace + _ = _stack__quote + _ = _stack__skip_array + _ = _stack__skip_number + _ = _stack__skip_object + _ = _stack__skip_one + _ = _stack__skip_one_fast + _ = _stack__u64toa + _ = _stack__unquote + _ = _stack__validate_one + _ = _stack__validate_utf8 + _ = _stack__validate_utf8_fast + _ = _stack__value + _ = _stack__vnumber + _ = _stack__vsigned + _ = _stack__vstring + _ = _stack__vunsigned +) diff --git a/vendor/github.com/bytedance/sonic/internal/native/types/types.go b/vendor/github.com/bytedance/sonic/internal/native/types/types.go new file mode 100644 index 000000000..00437303c --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/native/types/types.go @@ -0,0 +1,134 @@ +/* + * 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 types + +import ( + `fmt` + `sync` +) + +type ValueType int +type ParsingError uint +type SearchingError uint + +// NOTE: !NOT MODIFIED ONLY. +// This definitions are followed in native/types.h. + +const ( + V_EOF ValueType = 1 + V_NULL ValueType = 2 + V_TRUE ValueType = 3 + V_FALSE ValueType = 4 + V_ARRAY ValueType = 5 + V_OBJECT ValueType = 6 + V_STRING ValueType = 7 + V_DOUBLE ValueType = 8 + V_INTEGER ValueType = 9 + _ ValueType = 10 // V_KEY_SEP + _ ValueType = 11 // V_ELEM_SEP + _ ValueType = 12 // V_ARRAY_END + _ ValueType = 13 // V_OBJECT_END + V_MAX +) + +const ( + B_DOUBLE_UNQUOTE = 0 + B_UNICODE_REPLACE = 1 + B_VALIDATE_STRING = 5 +) + +const ( + F_DOUBLE_UNQUOTE = 1 << B_DOUBLE_UNQUOTE + F_UNICODE_REPLACE = 1 << B_UNICODE_REPLACE + F_VALIDATE_STRING = 1 << B_VALIDATE_STRING +) + +const ( + MAX_RECURSE = 4096 +) + +const ( + SPACE_MASK = (1 << ' ') | (1 << '\t') | (1 << '\r') | (1 << '\n') +) + +const ( + ERR_EOF ParsingError = 1 + ERR_INVALID_CHAR ParsingError = 2 + ERR_INVALID_ESCAPE ParsingError = 3 + ERR_INVALID_UNICODE ParsingError = 4 + ERR_INTEGER_OVERFLOW ParsingError = 5 + ERR_INVALID_NUMBER_FMT ParsingError = 6 + ERR_RECURSE_EXCEED_MAX ParsingError = 7 + ERR_FLOAT_INFINITY ParsingError = 8 + ERR_MISMATCH ParsingError = 9 + ERR_INVALID_UTF8 ParsingError = 10 +) + +var _ParsingErrors = []string{ + 0 : "ok", + ERR_EOF : "eof", + ERR_INVALID_CHAR : "invalid char", + ERR_INVALID_ESCAPE : "invalid escape char", + ERR_INVALID_UNICODE : "invalid unicode escape", + ERR_INTEGER_OVERFLOW : "integer overflow", + ERR_INVALID_NUMBER_FMT : "invalid number format", + ERR_RECURSE_EXCEED_MAX : "recursion exceeded max depth", + ERR_FLOAT_INFINITY : "float number is infinity", + ERR_MISMATCH : "mismatched type with value", + ERR_INVALID_UTF8 : "invalid UTF8", +} + +func (self ParsingError) Error() string { + return "json: error when parsing input: " + self.Message() +} + +func (self ParsingError) Message() string { + if int(self) < len(_ParsingErrors) { + return _ParsingErrors[self] + } else { + return fmt.Sprintf("unknown error %d", self) + } +} + +type JsonState struct { + Vt ValueType + Dv float64 + Iv int64 + Ep int + Dbuf *byte + Dcap int +} + +type StateMachine struct { + Sp int + Vt [MAX_RECURSE]int +} + +var stackPool = sync.Pool{ + New: func()interface{}{ + return &StateMachine{} + }, +} + +func NewStateMachine() *StateMachine { + return stackPool.Get().(*StateMachine) +} + +func FreeStateMachine(fsm *StateMachine) { + stackPool.Put(fsm) +} + diff --git a/vendor/github.com/bytedance/sonic/internal/resolver/asm.s b/vendor/github.com/bytedance/sonic/internal/resolver/asm.s new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/resolver/asm.s diff --git a/vendor/github.com/bytedance/sonic/internal/resolver/resolver.go b/vendor/github.com/bytedance/sonic/internal/resolver/resolver.go new file mode 100644 index 000000000..796d5d823 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/resolver/resolver.go @@ -0,0 +1,214 @@ +/* + * 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 resolver + +import ( + `fmt` + `reflect` + `strings` + `sync` +) + +type FieldOpts int +type OffsetType int + +const ( + F_omitempty FieldOpts = 1 << iota + F_stringize +) + +const ( + F_offset OffsetType = iota + F_deref +) + +type Offset struct { + Size uintptr + Kind OffsetType + Type reflect.Type +} + +type FieldMeta struct { + Name string + Path []Offset + Opts FieldOpts + Type reflect.Type +} + +func (self *FieldMeta) String() string { + var path []string + var opts []string + + /* dump the field path */ + for _, off := range self.Path { + if off.Kind == F_offset { + path = append(path, fmt.Sprintf("%d", off.Size)) + } else { + path = append(path, fmt.Sprintf("%d.(*%s)", off.Size, off.Type)) + } + } + + /* check for "string" */ + if (self.Opts & F_stringize) != 0 { + opts = append(opts, "string") + } + + /* check for "omitempty" */ + if (self.Opts & F_omitempty) != 0 { + opts = append(opts, "omitempty") + } + + /* format the field */ + return fmt.Sprintf( + "{Field \"%s\" @ %s, opts=%s, type=%s}", + self.Name, + strings.Join(path, "."), + strings.Join(opts, ","), + self.Type, + ) +} + +func (self *FieldMeta) optimize() { + var n int + var v uintptr + + /* merge adjacent offsets */ + for _, o := range self.Path { + if v += o.Size; o.Kind == F_deref { + self.Path[n].Size = v + self.Path[n].Type, v = o.Type, 0 + self.Path[n].Kind, n = F_deref, n + 1 + } + } + + /* last offset value */ + if v != 0 { + self.Path[n].Size = v + self.Path[n].Type = nil + self.Path[n].Kind = F_offset + n++ + } + + /* must be at least 1 offset */ + if n != 0 { + self.Path = self.Path[:n] + } else { + self.Path = []Offset{{Kind: F_offset}} + } +} + +func resolveFields(vt reflect.Type) []FieldMeta { + tfv := typeFields(vt) + ret := []FieldMeta(nil) + + /* convert each field */ + for _, fv := range tfv.list { + item := vt + path := []Offset(nil) + opts := FieldOpts(0) + + /* check for "string" */ + if fv.quoted { + opts |= F_stringize + } + + /* check for "omitempty" */ + if fv.omitEmpty { + opts |= F_omitempty + } + + /* dump the field path */ + for _, i := range fv.index { + kind := F_offset + fval := item.Field(i) + item = fval.Type + + /* deref the pointer if needed */ + if item.Kind() == reflect.Ptr { + kind = F_deref + item = item.Elem() + } + + /* add to path */ + path = append(path, Offset { + Kind: kind, + Type: item, + Size: fval.Offset, + }) + } + + /* get the index to the last offset */ + fvt := fv.typ + idx := len(path) - 1 + + /* do not dereference into fields */ + if path[idx].Kind == F_deref { + fvt = reflect.PtrTo(fvt) + path[idx].Kind = F_offset + } + + /* add to result */ + ret = append(ret, FieldMeta { + Type: fvt, + Opts: opts, + Path: path, + Name: fv.name, + }) + } + + /* optimize the offsets */ + for i := range ret { + ret[i].optimize() + } + + /* all done */ + return ret +} + +var ( + fieldLock = sync.RWMutex{} + fieldCache = map[reflect.Type][]FieldMeta{} +) + +func ResolveStruct(vt reflect.Type) []FieldMeta { + var ok bool + var fm []FieldMeta + + /* attempt to read from cache */ + fieldLock.RLock() + fm, ok = fieldCache[vt] + fieldLock.RUnlock() + + /* check if it was cached */ + if ok { + return fm + } + + /* otherwise use write-lock */ + fieldLock.Lock() + defer fieldLock.Unlock() + + /* double check */ + if fm, ok = fieldCache[vt]; ok { + return fm + } + + /* resolve the field */ + fm = resolveFields(vt) + fieldCache[vt] = fm + return fm +} diff --git a/vendor/github.com/bytedance/sonic/internal/resolver/stubs.go b/vendor/github.com/bytedance/sonic/internal/resolver/stubs.go new file mode 100644 index 000000000..ac27aa3d6 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/resolver/stubs.go @@ -0,0 +1,46 @@ +/* + * 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 resolver + +import ( + _ `encoding/json` + `reflect` + _ `unsafe` +) + +type StdField struct { + name string + nameBytes []byte + equalFold func() + nameNonEsc string + nameEscHTML string + tag bool + index []int + typ reflect.Type + omitEmpty bool + quoted bool + encoder func() +} + +type StdStructFields struct { + list []StdField + nameIndex map[string]int +} + +//go:noescape +//go:linkname typeFields encoding/json.typeFields +func typeFields(_ reflect.Type) StdStructFields diff --git a/vendor/github.com/bytedance/sonic/internal/rt/asm_amd64.s b/vendor/github.com/bytedance/sonic/internal/rt/asm_amd64.s new file mode 100644 index 000000000..8250e38d3 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/rt/asm_amd64.s @@ -0,0 +1,60 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT· + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·MoreStack(SB), NOSPLIT, $0 - 8 + NO_LOCAL_POINTERS +_entry: + MOVQ (TLS), R14 + MOVQ size+0(FP), R12 + NOTQ R12 + LEAQ (SP)(R12*1), R12 + CMPQ R12, 16(R14) + JBE _stack_grow + RET +_stack_grow: + CALL runtime·morestack_noctxt<>(SB) + JMP _entry + + +TEXT ·StopProf(SB), NOSPLIT, $0-0 + NO_LOCAL_POINTERS + CMPB github·com∕bytedance∕sonic∕internal∕rt·StopProfiling(SB), $0 + JEQ _ret_1 + MOVL $1, AX + LEAQ github·com∕bytedance∕sonic∕internal∕rt·yieldCount(SB), CX + LOCK + XADDL AX, (CX) + MOVL runtime·prof+4(SB), AX + TESTL AX, AX + JEQ _ret_1 + MOVL AX, github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB) + MOVL $0, runtime·prof+4(SB) +_ret_1: + RET + + +TEXT ·StartProf(SB), NOSPLIT, $0-0 + NO_LOCAL_POINTERS + CMPB github·com∕bytedance∕sonic∕internal∕rt·StopProfiling(SB), $0 + JEQ _ret_2 + MOVL $-1, AX + LEAQ github·com∕bytedance∕sonic∕internal∕rt·yieldCount(SB), CX + LOCK + XADDL AX, (CX) + CMPL github·com∕bytedance∕sonic∕internal∕rt·yieldCount(SB), $0 + JNE _ret_2 + CMPL runtime·prof+4(SB), $0 + JNE _ret_2 + CMPL github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB), $0 + JNE _branch_1 + MOVL $100, github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB) +_branch_1: + MOVL github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB), AX + MOVL AX, runtime·prof+4(SB) +_ret_2: + RET +
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/rt/asm_arm64.s b/vendor/github.com/bytedance/sonic/internal/rt/asm_arm64.s new file mode 100644 index 000000000..a168a8266 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/rt/asm_arm64.s @@ -0,0 +1,10 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·MoreStack(SB), NOSPLIT, $0 - 8 + NO_LOCAL_POINTERS + RET diff --git a/vendor/github.com/bytedance/sonic/internal/rt/fastmem.go b/vendor/github.com/bytedance/sonic/internal/rt/fastmem.go new file mode 100644 index 000000000..358ce80ce --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/rt/fastmem.go @@ -0,0 +1,113 @@ +/* + * 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 rt + +import ( + `unsafe` + `reflect` +) + +//go:nosplit +func Get16(v []byte) int16 { + return *(*int16)((*GoSlice)(unsafe.Pointer(&v)).Ptr) +} + +//go:nosplit +func Get32(v []byte) int32 { + return *(*int32)((*GoSlice)(unsafe.Pointer(&v)).Ptr) +} + +//go:nosplit +func Get64(v []byte) int64 { + return *(*int64)((*GoSlice)(unsafe.Pointer(&v)).Ptr) +} + +//go:nosplit +func Mem2Str(v []byte) (s string) { + (*GoString)(unsafe.Pointer(&s)).Len = (*GoSlice)(unsafe.Pointer(&v)).Len + (*GoString)(unsafe.Pointer(&s)).Ptr = (*GoSlice)(unsafe.Pointer(&v)).Ptr + return +} + +//go:nosplit +func Str2Mem(s string) (v []byte) { + (*GoSlice)(unsafe.Pointer(&v)).Cap = (*GoString)(unsafe.Pointer(&s)).Len + (*GoSlice)(unsafe.Pointer(&v)).Len = (*GoString)(unsafe.Pointer(&s)).Len + (*GoSlice)(unsafe.Pointer(&v)).Ptr = (*GoString)(unsafe.Pointer(&s)).Ptr + return +} + +func BytesFrom(p unsafe.Pointer, n int, c int) (r []byte) { + (*GoSlice)(unsafe.Pointer(&r)).Ptr = p + (*GoSlice)(unsafe.Pointer(&r)).Len = n + (*GoSlice)(unsafe.Pointer(&r)).Cap = c + return +} + +func FuncAddr(f interface{}) unsafe.Pointer { + if vv := UnpackEface(f); vv.Type.Kind() != reflect.Func { + panic("f is not a function") + } else { + return *(*unsafe.Pointer)(vv.Value) + } +} + +func IndexChar(src string, index int) unsafe.Pointer { + return unsafe.Pointer(uintptr((*GoString)(unsafe.Pointer(&src)).Ptr) + uintptr(index)) +} + +func IndexByte(ptr []byte, index int) unsafe.Pointer { + return unsafe.Pointer(uintptr((*GoSlice)(unsafe.Pointer(&ptr)).Ptr) + uintptr(index)) +} + +//go:nosplit +func GuardSlice(buf *[]byte, n int) { + c := cap(*buf) + l := len(*buf) + if c-l < n { + c = c>>1 + n + l + if c < 32 { + c = 32 + } + tmp := make([]byte, l, c) + copy(tmp, *buf) + *buf = tmp + } + return +} + +//go:nosplit +func Ptr2SlicePtr(s unsafe.Pointer, l int, c int) unsafe.Pointer { + slice := &GoSlice{ + Ptr: s, + Len: l, + Cap: c, + } + return unsafe.Pointer(slice) +} + +//go:nosplit +func StrPtr(s string) unsafe.Pointer { + return (*GoString)(unsafe.Pointer(&s)).Ptr +} + +//go:nosplit +func StrFrom(p unsafe.Pointer, n int64) (s string) { + (*GoString)(unsafe.Pointer(&s)).Ptr = p + (*GoString)(unsafe.Pointer(&s)).Len = int(n) + return +}
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go b/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go new file mode 100644 index 000000000..87df6b94a --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go @@ -0,0 +1,200 @@ +/* + * 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 rt + +import ( + `reflect` + `unsafe` +) + +var ( + reflectRtypeItab = findReflectRtypeItab() +) + +const ( + F_direct = 1 << 5 + F_kind_mask = (1 << 5) - 1 +) + +type GoType struct { + Size uintptr + PtrData uintptr + Hash uint32 + Flags uint8 + Align uint8 + FieldAlign uint8 + KindFlags uint8 + Traits unsafe.Pointer + GCData *byte + Str int32 + PtrToSelf int32 +} + +func (self *GoType) Kind() reflect.Kind { + return reflect.Kind(self.KindFlags & F_kind_mask) +} + +func (self *GoType) Pack() (t reflect.Type) { + (*GoIface)(unsafe.Pointer(&t)).Itab = reflectRtypeItab + (*GoIface)(unsafe.Pointer(&t)).Value = unsafe.Pointer(self) + return +} + +func (self *GoType) String() string { + return self.Pack().String() +} + +func (self *GoType) Indirect() bool { + return self.KindFlags & F_direct == 0 +} + +type GoMap struct { + Count int + Flags uint8 + B uint8 + Overflow uint16 + Hash0 uint32 + Buckets unsafe.Pointer + OldBuckets unsafe.Pointer + Evacuate uintptr + Extra unsafe.Pointer +} + +type GoMapIterator struct { + K unsafe.Pointer + V unsafe.Pointer + T *GoMapType + H *GoMap + Buckets unsafe.Pointer + Bptr *unsafe.Pointer + Overflow *[]unsafe.Pointer + OldOverflow *[]unsafe.Pointer + StartBucket uintptr + Offset uint8 + Wrapped bool + B uint8 + I uint8 + Bucket uintptr + CheckBucket uintptr +} + +type GoItab struct { + it unsafe.Pointer + Vt *GoType + hv uint32 + _ [4]byte + fn [1]uintptr +} + +type GoIface struct { + Itab *GoItab + Value unsafe.Pointer +} + +type GoEface struct { + Type *GoType + Value unsafe.Pointer +} + +func (self GoEface) Pack() (v interface{}) { + *(*GoEface)(unsafe.Pointer(&v)) = self + return +} + +type GoPtrType struct { + GoType + Elem *GoType +} + +type GoMapType struct { + GoType + Key *GoType + Elem *GoType + Bucket *GoType + Hasher func(unsafe.Pointer, uintptr) uintptr + KeySize uint8 + ElemSize uint8 + BucketSize uint16 + Flags uint32 +} + +func (self *GoMapType) IndirectElem() bool { + return self.Flags & 2 != 0 +} + +type GoStructType struct { + GoType + Pkg *byte + Fields []GoStructField +} + +type GoStructField struct { + Name *byte + Type *GoType + OffEmbed uintptr +} + +type GoInterfaceType struct { + GoType + PkgPath *byte + Methods []GoInterfaceMethod +} + +type GoInterfaceMethod struct { + Name int32 + Type int32 +} + +type GoSlice struct { + Ptr unsafe.Pointer + Len int + Cap int +} + +type GoString struct { + Ptr unsafe.Pointer + Len int +} + +func PtrElem(t *GoType) *GoType { + return (*GoPtrType)(unsafe.Pointer(t)).Elem +} + +func MapType(t *GoType) *GoMapType { + return (*GoMapType)(unsafe.Pointer(t)) +} + +func IfaceType(t *GoType) *GoInterfaceType { + return (*GoInterfaceType)(unsafe.Pointer(t)) +} + +func UnpackType(t reflect.Type) *GoType { + return (*GoType)((*GoIface)(unsafe.Pointer(&t)).Value) +} + +func UnpackEface(v interface{}) GoEface { + return *(*GoEface)(unsafe.Pointer(&v)) +} + +func UnpackIface(v interface{}) GoIface { + return *(*GoIface)(unsafe.Pointer(&v)) +} + +func findReflectRtypeItab() *GoItab { + v := reflect.TypeOf(struct{}{}) + return (*GoIface)(unsafe.Pointer(&v)).Itab +} diff --git a/vendor/github.com/bytedance/sonic/internal/rt/gcwb.go b/vendor/github.com/bytedance/sonic/internal/rt/gcwb.go new file mode 100644 index 000000000..c3217c899 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/rt/gcwb.go @@ -0,0 +1,124 @@ +/* + * 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 rt + +import ( + `os` + `sync/atomic` + `unsafe` + + `golang.org/x/arch/x86/x86asm` +) + +const ( + _MaxInstr = 15 +) + +func isvar(arg x86asm.Arg) bool { + v, ok := arg.(x86asm.Mem) + return ok && v.Base == x86asm.RIP +} + +func iszero(arg x86asm.Arg) bool { + v, ok := arg.(x86asm.Imm) + return ok && v == 0 +} + +func GcwbAddr() uintptr { + var err error + var off uintptr + var ins x86asm.Inst + + /* get the function address */ + pc := uintptr(0) + fp := FuncAddr(atomic.StorePointer) + + /* search within the first 16 instructions */ + for i := 0; i < 16; i++ { + mem := unsafe.Pointer(uintptr(fp) + pc) + buf := BytesFrom(mem, _MaxInstr, _MaxInstr) + + /* disassemble the instruction */ + if ins, err = x86asm.Decode(buf, 64); err != nil { + panic("gcwbaddr: " + err.Error()) + } + + /* check for a byte comparison with zero */ + if ins.Op == x86asm.CMP && ins.MemBytes == 1 && isvar(ins.Args[0]) && iszero(ins.Args[1]) { + off = pc + uintptr(ins.Len) + uintptr(ins.Args[0].(x86asm.Mem).Disp) + break + } + + /* move to next instruction */ + nb := ins.Len + pc += uintptr(nb) + } + + /* check for address */ + if off == 0 { + panic("gcwbaddr: could not locate the variable `writeBarrier`") + } else { + return uintptr(fp) + off + } +} + +// StopProfiling is used to stop traceback introduced by SIGPROF while native code is running. +// WARN: this option is only a workaround for traceback issue (https://github.com/bytedance/sonic/issues/310), +// and will be dropped when the issue is fixed. +var StopProfiling = os.Getenv("SONIC_STOP_PROFILING") != "" + +// WARN: must be aligned with runtime.Prof +// type Prof struct { +// signalLock uint32 +// hz int32 +// } + +var ( + // // go:linkname runtimeProf runtime.prof + // runtimeProf Prof + + // count of native-C calls + yieldCount uint32 + + // previous value of runtimeProf.hz + oldHz int32 +) + +//go:nosplit +func MoreStack(size uintptr) + +func StopProf() + +// func StopProf() { +// atomic.AddUint32(&yieldCount, 1) +// if runtimeProf.hz != 0 { +// oldHz = runtimeProf.hz +// runtimeProf.hz = 0 +// } +// } + +func StartProf() + +// func StartProf() { +// atomic.AddUint32(&yieldCount, ^uint32(0)) +// if yieldCount == 0 && runtimeProf.hz == 0 { +// if oldHz == 0 { +// oldHz = 100 +// } +// runtimeProf.hz = oldHz +// } +// } diff --git a/vendor/github.com/bytedance/sonic/internal/rt/int48.go b/vendor/github.com/bytedance/sonic/internal/rt/int48.go new file mode 100644 index 000000000..e9f82d731 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/rt/int48.go @@ -0,0 +1,36 @@ +/* + * 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 rt + +const ( + MinInt48 = -(1 << 47) + MaxInt48 = +(1 << 47) - 1 +) + +func PackInt(v int) uint64 { + if u := uint64(v); v < MinInt48 || v > MaxInt48 { + panic("int48 out of range") + } else { + return ((u >> 63) << 47) | (u & 0x00007fffffffffff) + } +} + +func UnpackInt(v uint64) int { + v &= 0x0000ffffffffffff + v |= (v >> 47) * (0xffff << 48) + return int(v) +} diff --git a/vendor/github.com/bytedance/sonic/internal/rt/stackmap.go b/vendor/github.com/bytedance/sonic/internal/rt/stackmap.go new file mode 100644 index 000000000..e2c28c598 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/internal/rt/stackmap.go @@ -0,0 +1,180 @@ +/** + * Copyright 2023 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 rt + +import ( + `fmt` + `strings` + `unsafe` + +) + +type Bitmap struct { + N int + B []byte +} + +func (self *Bitmap) grow() { + if self.N >= len(self.B) * 8 { + self.B = append(self.B, 0) + } +} + +func (self *Bitmap) mark(i int, bv int) { + if bv != 0 { + self.B[i / 8] |= 1 << (i % 8) + } else { + self.B[i / 8] &^= 1 << (i % 8) + } +} + +func (self *Bitmap) Set(i int, bv int) { + if i >= self.N { + panic("bitmap: invalid bit position") + } else { + self.mark(i, bv) + } +} + +func (self *Bitmap) Append(bv int) { + self.grow() + self.mark(self.N, bv) + self.N++ +} + +func (self *Bitmap) AppendMany(n int, bv int) { + for i := 0; i < n; i++ { + self.Append(bv) + } +} + +// var ( +// _stackMapLock = sync.Mutex{} +// _stackMapCache = make(map[*StackMap]struct{}) +// ) + +type BitVec struct { + N uintptr + B unsafe.Pointer +} + +func (self BitVec) Bit(i uintptr) byte { + return (*(*byte)(unsafe.Pointer(uintptr(self.B) + i / 8)) >> (i % 8)) & 1 +} + +func (self BitVec) String() string { + var i uintptr + var v []string + + /* add each bit */ + for i = 0; i < self.N; i++ { + v = append(v, fmt.Sprintf("%d", self.Bit(i))) + } + + /* join them together */ + return fmt.Sprintf( + "BitVec { %s }", + strings.Join(v, ", "), + ) +} + +type StackMap struct { + N int32 + L int32 + B [1]byte +} + +// func (self *StackMap) add() { +// _stackMapLock.Lock() +// _stackMapCache[self] = struct{}{} +// _stackMapLock.Unlock() +// } + +func (self *StackMap) Pin() uintptr { + // self.add() + return uintptr(unsafe.Pointer(self)) +} + +func (self *StackMap) Get(i int32) BitVec { + return BitVec { + N: uintptr(self.L), + B: unsafe.Pointer(uintptr(unsafe.Pointer(&self.B)) + uintptr(i * ((self.L + 7) >> 3))), + } +} + +func (self *StackMap) String() string { + sb := strings.Builder{} + sb.WriteString("StackMap {") + + /* dump every stack map */ + for i := int32(0); i < self.N; i++ { + sb.WriteRune('\n') + sb.WriteString(" " + self.Get(i).String()) + } + + /* close the stackmap */ + sb.WriteString("\n}") + return sb.String() +} + +func (self *StackMap) MarshalBinary() ([]byte, error) { + size := int(self.N) * int(self.L) + int(unsafe.Sizeof(self.L)) + int(unsafe.Sizeof(self.N)) + return BytesFrom(unsafe.Pointer(self), size, size), nil +} + +var ( + byteType = UnpackEface(byte(0)).Type +) + +const ( + _StackMapSize = unsafe.Sizeof(StackMap{}) +) + +//go:linkname mallocgc runtime.mallocgc +//goland:noinspection GoUnusedParameter +func mallocgc(nb uintptr, vt *GoType, zero bool) unsafe.Pointer + +type StackMapBuilder struct { + b Bitmap +} + +func (self *StackMapBuilder) Build() (p *StackMap) { + nb := len(self.b.B) + bm := mallocgc(_StackMapSize + uintptr(nb) - 1, byteType, false) + + /* initialize as 1 bitmap of N bits */ + p = (*StackMap)(bm) + p.N, p.L = 1, int32(self.b.N) + copy(BytesFrom(unsafe.Pointer(&p.B), nb, nb), self.b.B) + return +} + +func (self *StackMapBuilder) AddField(ptr bool) { + if ptr { + self.b.Append(1) + } else { + self.b.Append(0) + } +} + +func (self *StackMapBuilder) AddFields(n int, ptr bool) { + if ptr { + self.b.AppendMany(n, 1) + } else { + self.b.AppendMany(n, 0) + } +}
\ No newline at end of file |