diff --git a/.github/workflows/benchmark-linux-arm64.yml b/.github/workflows/benchmark-linux-arm64.yml index 9dbcab5b4..dde79a64d 100644 --- a/.github/workflows/benchmark-linux-arm64.yml +++ b/.github/workflows/benchmark-linux-arm64.yml @@ -1,6 +1,6 @@ name: Benchmark Linux-ARM -on: pull_request +on: push jobs: build: diff --git a/.github/workflows/benchmark-linux-x64.yml b/.github/workflows/benchmark-linux-x64.yml index 47d1bfb0a..dc20f5f49 100644 --- a/.github/workflows/benchmark-linux-x64.yml +++ b/.github/workflows/benchmark-linux-x64.yml @@ -1,6 +1,6 @@ name: Benchmark Linux-X64 -on: pull_request +on: push jobs: build: diff --git a/.github/workflows/compatibility_test-windows.yml b/.github/workflows/compatibility_test-windows.yml index e854c8fe1..6f91da564 100644 --- a/.github/workflows/compatibility_test-windows.yml +++ b/.github/workflows/compatibility_test-windows.yml @@ -1,6 +1,6 @@ name: Compatibility Test Windows-X64 -on: pull_request +on: push jobs: build: diff --git a/.github/workflows/compatibility_test.yml b/.github/workflows/compatibility_test.yml index cb4b23d4b..bed37d4e3 100644 --- a/.github/workflows/compatibility_test.yml +++ b/.github/workflows/compatibility_test.yml @@ -1,6 +1,6 @@ name: Compatibility Test Linux-X64|ARM -on: pull_request +on: push jobs: build: diff --git a/.github/workflows/fuzzing-linux-x64.yml b/.github/workflows/fuzzing-linux-x64.yml index d7246b2f1..2ceb91a09 100644 --- a/.github/workflows/fuzzing-linux-x64.yml +++ b/.github/workflows/fuzzing-linux-x64.yml @@ -1,6 +1,6 @@ name: Fuzz Test Linux-X64 -on: pull_request +on: push jobs: build: diff --git a/.github/workflows/generic_test.yml b/.github/workflows/generic_test.yml index 3ebe1a8dc..7bb608f73 100644 --- a/.github/workflows/generic_test.yml +++ b/.github/workflows/generic_test.yml @@ -1,6 +1,6 @@ name: Generic Test Go1.18-Linux-X64 -on: pull_request +on: push jobs: build: diff --git a/.github/workflows/license-check.yml b/.github/workflows/license-check.yml index a2142dc1a..fb699d926 100644 --- a/.github/workflows/license-check.yml +++ b/.github/workflows/license-check.yml @@ -1,6 +1,6 @@ name: License Check -on: pull_request +on: push jobs: build: diff --git a/.gitmodules b/.gitmodules index b8d11c921..7b56db900 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,7 @@ [submodule "tools/asm2asm"] path = tools/asm2asm url = https://github.com/chenzhuoyu/asm2asm + +[submodule "tools/simde"] + path = tools/simde + url = https://github.com/simd-everywhere/simde diff --git a/Makefile b/Makefile index c672c313e..a48e5b2a8 100644 --- a/Makefile +++ b/Makefile @@ -22,20 +22,23 @@ SRC_FILE := native/native.c CPU_avx := amd64 CPU_avx2 := amd64 CPU_sse := amd64 +CPU_neon := arm64 -TMPL_avx := fastint_amd64_test fastfloat_amd64_test native_amd64_test recover_amd64_test -TMPL_avx2 := fastint_amd64_test fastfloat_amd64_test native_amd64_test recover_amd64_test -TMPL_sse := fastint_amd64_test fastfloat_amd64_test native_amd64_test recover_amd64_test +TMPL_amd64 := fastint_test fastfloat_test native_test recover_amd64_test +TMPL_arm64 := fastint_test fastfloat_test native_test recover_arm64_test native_export_arm64 -CFLAGS_avx := -msse -mno-sse4 -mavx -mpclmul -mno-avx2 -mstack-alignment=0 -DUSE_AVX=1 -DUSE_AVX2=0 -CFLAGS_avx2 := -msse -mno-sse4 -mavx -mpclmul -mavx2 -mstack-alignment=0 -DUSE_AVX=1 -DUSE_AVX2=1 -CFLAGS_sse := -msse -mno-sse4 -mno-avx -mno-avx2 -mpclmul - -CC_amd64 := clang ASM2ASM_amd64 := tools/asm2asm/asm2asm.py +ASM2ASM_arm64 := tools/asm2arm/arm.py + +ASM_FLAGS_amd64 := -r +ASM_FLAGS_arm64 := + +ASM_OUT_amd64 := native_text_amd64.go +ASM_OUT_arm64 := native_arm64.s + +CC := clang CFLAGS := -mno-red-zone -CFLAGS += -target x86_64-apple-macos11 CFLAGS += -fno-asynchronous-unwind-tables CFLAGS += -fno-builtin CFLAGS += -fno-exceptions @@ -43,7 +46,11 @@ CFLAGS += -fno-rtti CFLAGS += -fno-stack-protector CFLAGS += -nostdlib CFLAGS += -O3 -CFLAGS += -Wall -Werror +# CFLAGS += -Wall -Werror +CFLAGS_avx := -target x86_64-apple-macos11 -msse -mno-sse4 -mavx -mpclmul -mno-avx2 -mstack-alignment=0 -DUSE_AVX=1 -DUSE_AVX2=0 +CFLAGS_avx2 := -target x86_64-apple-macos11 -msse -mno-sse4 -mavx -mpclmul -mavx2 -mstack-alignment=0 -DUSE_AVX=1 -DUSE_AVX2=1 +CFLAGS_sse := -target x86_64-apple-macos11 -msse -mno-sse4 -mno-avx -mno-avx2 -mpclmul +CFLAGS_neon := -target aarch64-apple-macos11 -march=armv8-a+simd -Itools/simde/simde NATIVE_SRC := $(wildcard native/*.h) NATIVE_SRC += $(wildcard native/*.c) @@ -63,19 +70,12 @@ ${@dest}: ${@tmpl} endef define build_arch - $(eval @cpu := $(value CPU_$(1))) - $(eval @deps := $(foreach tmpl,$(value TMPL_$(1)),${OUT_DIR}/$(1)/${tmpl}.go)) - $(eval @asmin := ${TMP_DIR}/$(1)/native.s) - $(eval @asmout := ${OUT_DIR}/$(1)/native_text_${@cpu}.go) - $(eval @stubin := ${OUT_DIR}/native_${@cpu}.tmpl) - $(eval @stubout := ${OUT_DIR}/$(1)/native_${@cpu}.go) - -$(1): ${@asmout} ${@deps} - -${@asmout}: ${@stubout} ${NATIVE_SRC} - mkdir -p ${TMP_DIR}/$(1) - $${CC_${@cpu}} $${CFLAGS} $${CFLAGS_$(1)} -S -o ${TMP_DIR}/$(1)/native.s ${SRC_FILE} - python3 $${ASM2ASM_${@cpu}} -r ${@stubout} ${TMP_DIR}/$(1)/native.s +$(eval @cpu := $(value CPU_$(1))) +$(eval @deps := $(foreach tmpl,$(value TMPL_${@cpu}),${OUT_DIR}/$(1)/${tmpl}.go)) +$(eval @asmin := ${TMP_DIR}/$(1)/native.s) +$(eval @asmout := ${OUT_DIR}/$(1)/$(value ASM_OUT_${@cpu})) +$(eval @stubin := ${OUT_DIR}/native_${@cpu}.tmpl) +$(eval @stubout := ${OUT_DIR}/$(1)/native_${@cpu}.go) $(eval $(call \ build_tmpl, \ @@ -84,9 +84,16 @@ $(eval $(call \ ${@stubout} \ )) +$(1): ${@asmout} ${@deps} + +${@asmout}: ${@stubout} ${NATIVE_SRC} + mkdir -p ${TMP_DIR}/$(1) + $${CC} $${CFLAGS} $${CFLAGS_$(1)} -S -o ${TMP_DIR}/$(1)/native.s ${SRC_FILE} + python3 $${ASM2ASM_${@cpu}} $${ASM_FLAGS_${@cpu}} ${@stubout} ${TMP_DIR}/$(1)/native.s + $(foreach \ tmpl, \ - $(value TMPL_$(1)), \ + $(value TMPL_${@cpu}), \ $(eval $(call \ build_tmpl, \ $(1), \ diff --git a/ast/api_amd64.go b/ast/api.go similarity index 92% rename from ast/api_amd64.go rename to ast/api.go index fa4375630..373d62a9f 100644 --- a/ast/api_amd64.go +++ b/ast/api.go @@ -1,4 +1,4 @@ -// +build amd64,go1.16,!go1.23 +// +build amd64,go1.16,!go1.23 arm64,go1.20,!go1.23 /* * Copyright 2022 ByteDance Inc. @@ -27,7 +27,6 @@ import ( `github.com/bytedance/sonic/internal/native/types` `github.com/bytedance/sonic/internal/rt` uq `github.com/bytedance/sonic/unquote` - `github.com/chenzhuoyu/base64x` ) var typeByte = rt.UnpackEface(byte(0)).Type @@ -77,14 +76,6 @@ func unquote(src string) (string, types.ParsingError) { return uq.String(src) } -func decodeBase64(src string) ([]byte, error) { - return base64x.StdEncoding.DecodeString(src) -} - -func encodeBase64(src []byte) string { - return base64x.StdEncoding.EncodeToString(src) -} - func (self *Parser) decodeValue() (val types.JsonState) { sv := (*rt.GoString)(unsafe.Pointer(&self.s)) flag := types.F_USE_NUMBER diff --git a/ast/api_compat.go b/ast/api_compat.go index 9244e76e1..3da38a409 100644 --- a/ast/api_compat.go +++ b/ast/api_compat.go @@ -1,111 +1,109 @@ -// +build !amd64 !go1.16 go1.23 +// +build !amd64,!arm64 go1.23 !go1.16 arm64,!go1.20 /* - * Copyright 2022 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. - */ +* Copyright 2022 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 ast import ( - `encoding/base64` - `encoding/json` + `encoding/json` - `github.com/bytedance/sonic/internal/native/types` - `github.com/bytedance/sonic/internal/rt` + `github.com/bytedance/sonic/internal/native/types` + `github.com/bytedance/sonic/internal/rt` ) func init() { - println("WARNING: sonic only supports Go1.16~1.22 && CPU amd64, but your environment is not suitable") + println("WARNING:(ast) sonic only supports Go1.16~1.21, but your environment is not suitable") } func quote(buf *[]byte, val string) { - quoteString(buf, val) + quoteString(buf, val) } func unquote(src string) (string, types.ParsingError) { - sp := rt.IndexChar(src, -1) - out, ok := unquoteBytes(rt.BytesFrom(sp, len(src)+2, len(src)+2)) - if !ok { - return "", types.ERR_INVALID_ESCAPE - } - return rt.Mem2Str(out), 0 + sp := rt.IndexChar(src, -1) + out, ok := unquoteBytes(rt.BytesFrom(sp, len(src)+2, len(src)+2)) + if !ok { + return "", types.ERR_INVALID_ESCAPE + } + return rt.Mem2Str(out), 0 } -func decodeBase64(src string) ([]byte, error) { - return base64.StdEncoding.DecodeString(src) -} - -func encodeBase64(src []byte) string { - return base64.StdEncoding.EncodeToString(src) -} func (self *Parser) decodeValue() (val types.JsonState) { - e, v := decodeValue(self.s, self.p, self.dbuf == nil) - if e < 0 { - return v - } - self.p = e - return v + e, v := decodeValue(self.s, self.p, self.dbuf == nil) + if e < 0 { + return v + } + self.p = e + return v } func (self *Parser) skip() (int, types.ParsingError) { - e, s := skipValue(self.s, self.p) - if e < 0 { - return self.p, types.ParsingError(-e) - } - self.p = e - return s, 0 + e, s := skipValue(self.s, self.p) + if e < 0 { + return self.p, types.ParsingError(-e) + } + self.p = e + return s, 0 } func (self *Parser) skipFast() (int, types.ParsingError) { - e, s := skipValueFast(self.s, self.p) - if e < 0 { - return self.p, types.ParsingError(-e) - } - self.p = e - return s, 0 + e, s := skipValueFast(self.s, self.p) + if e < 0 { + return self.p, types.ParsingError(-e) + } + self.p = e + return s, 0 } func (self *Node) encodeInterface(buf *[]byte) error { - out, err := json.Marshal(self.packAny()) - if err != nil { - return err - } - *buf = append(*buf, out...) - return nil + out, err := json.Marshal(self.packAny()) + if err != nil { + return err + } + *buf = append(*buf, out...) + return nil } func (self *Parser) getByPath(path ...interface{}) (int, types.ParsingError) { - var err types.ParsingError - for _, p := range path { - if idx, ok := p.(int); ok && idx >= 0 { - if err = self.searchIndex(idx); err != 0 { - return -1, err - } - } else if key, ok := p.(string); ok { - if err = self.searchKey(key); err != 0 { - return -1, err - } - } else { - panic("path must be either int(>=0) or string") - } - } + var err types.ParsingError - var start int - if start, err = self.skip(); err != 0 { - return -1, err - } - return start, 0 -} + for _, p := range path { + if idx, ok := p.(int); ok && idx >= 0 { + if err = self.searchIndex(idx); err != 0 { + return -1, err + } + } else if key, ok := p.(string); ok { + if err = self.searchKey(key); err != 0 { + return -1, err + } + } else { + panic("path must be either int(>=0) or string") + } + } + + var start = self.p + if start, err = self.skip(); err != 0 { + return -1, err + } + ns := len(self.s) + if self.p > ns || start >= ns || start>=self.p { + return -1, types.ERR_EOF + } + + return start, 0 +} \ No newline at end of file diff --git a/ast/api_amd64_test.go b/ast/api_native_test.go similarity index 63% rename from ast/api_amd64_test.go rename to ast/api_native_test.go index a659fe98f..17b13a417 100644 --- a/ast/api_amd64_test.go +++ b/ast/api_native_test.go @@ -20,6 +20,10 @@ package ast import ( `encoding/json` + `fmt` + `reflect` + `runtime` + `runtime/debug` `testing` `github.com/bytedance/sonic/encoder` @@ -112,4 +116,86 @@ func TestSortNodeTwitter(t *testing.T) { require.Equal(t, expObj, actObj) require.Equal(t, len(exp), len(act)) require.Equal(t, string(exp), string(act)) +} + +func TestNodeAny(t *testing.T) { + empty := Node{} + _,err := empty.SetAny("any", map[string]interface{}{"a": []int{0}}) + if err != nil { + t.Fatal(err) + } + if m, err := empty.Get("any").Interface(); err != nil { + t.Fatal(err) + } else if v, ok := m.(map[string]interface{}); !ok { + t.Fatal(v) + } + if buf, err := empty.MarshalJSON(); err != nil { + t.Fatal(err) + } else if string(buf) != `{"any":{"a":[0]}}` { + t.Fatal(string(buf)) + } + if _, err := empty.Set("any2", Node{}); err != nil { + t.Fatal(err) + } + if err := empty.Get("any2").AddAny(nil); err != nil { + t.Fatal(err) + } + if buf, err := empty.MarshalJSON(); err != nil { + t.Fatal(err) + } else if string(buf) != `{"any":{"a":[0]},"any2":[null]}` { + t.Fatal(string(buf)) + } + if _, err := empty.Get("any2").SetAnyByIndex(0, NewNumber("-0.0")); err != nil { + t.Fatal(err) + } + if buf, err := empty.MarshalJSON(); err != nil { + t.Fatal(err) + } else if string(buf) != `{"any":{"a":[0]},"any2":[-0.0]}` { + t.Fatal(string(buf)) + } +} + + +func TestTypeCast2(t *testing.T) { + type tcase struct { + method string + node Node + exp interface{} + err error + } + var cases = []tcase{ + {"Raw", NewAny(""), "\"\"", nil}, + } + + for i, c := range cases { + fmt.Println(i, c) + rt := reflect.ValueOf(&c.node) + m := rt.MethodByName(c.method) + rets := m.Call([]reflect.Value{}) + if len(rets) != 2 { + t.Fatal(i, rets) + } + require.Equal(t, rets[0].Interface(), c.exp) + v := rets[1].Interface(); + if v != c.err { + t.Fatal(i, v) + } + } +} + +func TestStackAny(t *testing.T) { + var obj = stackObj() + any := NewAny(obj) + fmt.Printf("any: %#v\n", any) + runtime.GC() + debug.FreeOSMemory() + println("finish GC") + buf, err := any.MarshalJSON() + println("finish marshal") + if err != nil { + t.Fatal(err) + } + if string(buf) != "1" { + t.Fatal(string(buf)) + } } \ No newline at end of file diff --git a/ast/api_test.go b/ast/api_test.go deleted file mode 100644 index 801aa49a4..000000000 --- a/ast/api_test.go +++ /dev/null @@ -1,188 +0,0 @@ -/* - * Copyright 2022 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 ast - -import ( - `testing` - `strings` - - `github.com/stretchr/testify/assert` -) - -type Path = []interface{} - -type testGetApi struct { - json string - path Path -} - -type checkError func(error) bool - -func isSyntaxError(err error) bool { - if err == nil { - return false - } - return strings.HasPrefix(err.Error(), `"Syntax error at index`) -} - -func isEmptySource(err error) bool { - if err == nil { - return false - } - return strings.Contains(err.Error(), "no sources available") -} - -func isErrNotExist(err error) bool { - return err == ErrNotExist -} - -func isErrUnsupportType(err error) bool { - return err == ErrUnsupportType -} - -func testSyntaxJson(t *testing.T, json string, path ...interface{}) { - search := NewSearcher(json) - _, err := search.GetByPath(path...) - assert.True(t, isSyntaxError(err)) -} - -func TestGetFromEmptyJson(t *testing.T) { - tests := []testGetApi { - { "", nil }, - { "", Path{}}, - { "", Path{""}}, - { "", Path{0}}, - { "", Path{"", ""}}, - } - for _, test := range tests { - f := func(t *testing.T) { - search := NewSearcher(test.json) - _, err := search.GetByPath(test.path...) - assert.True(t, isEmptySource(err)) - } - t.Run(test.json, f) - } -} - -func TestGetFromSyntaxError(t *testing.T) { - tests := []testGetApi { - { " \r\n\f\t", Path{} }, - { "123.", Path{} }, - { "+124", Path{} }, - { "-", Path{} }, - { "-e123", Path{} }, - { "-1.e123", Path{} }, - { "-12e456.1", Path{} }, - { "-12e.1", Path{} }, - { "[", Path{} }, - { "{", Path{} }, - { "[}", Path{} }, - { "{]", Path{} }, - { "{,}", Path{} }, - { "[,]", Path{} }, - { "tru", Path{} }, - { "fals", Path{} }, - { "nul", Path{} }, - { `{"a":"`, Path{"a"} }, - { `{"`, Path{} }, - { `"`, Path{} }, - { `"\"`, Path{} }, - { `"\\\"`, Path{} }, - { `"hello`, Path{} }, - { `{{}}`, Path{} }, - { `{[]}`, Path{} }, - { `{:,}`, Path{} }, - { `{test:error}`, Path{} }, - { `{":true}`, Path{} }, - { `{"" false}`, Path{} }, - { `{ "" : "false }`, Path{} }, - { `{"":"",}`, Path{} }, - { `{ " test : true}`, Path{} }, - { `{ "test" : tru }`, Path{} }, - { `{ "test" : true , }`, Path{} }, - { `{ {"test" : true , } }`, Path{} }, - { `{"test":1. }`, Path{} }, - { `{"\\\""`, Path{} }, - { `{"\\\"":`, Path{} }, - { `{"\\\":",""}`, Path{} }, - { `[{]`, Path{} }, - { `[tru]`, Path{} }, - { `[-1.]`, Path{} }, - { `[[]`, Path{} }, - { `[[],`, Path{} }, - { `[ true , false , [ ]`, Path{} }, - { `[true, false, [],`, Path{} }, - { `[true, false, [],]`, Path{} }, - { `{"key": [true, false, []], "key2": {{}}`, Path{} }, - } - - for _, test := range tests { - f := func(t *testing.T) { - testSyntaxJson(t, test.json, test.path...) - path := append(Path{"key"}, test.path...) - testSyntaxJson(t, `{"key":` + test.json, path...) - path = append(Path{""}, test.path...) - testSyntaxJson(t, `{"":` + test.json, path...) - path = append(Path{1}, test.path...) - testSyntaxJson(t, `["",` + test.json, path...) - } - t.Run(test.json, f) - } -} - -// NOTE: GetByPath API not validate the undemanded fields for performance. -func TestGetWithInvalidUndemandedField(t *testing.T) { - type Any = interface{} - tests := []struct { - json string - path Path - exp Any - } { - { "-0xyz", Path{}, Any(float64(-0))}, - { "-12e4xyz", Path{}, Any(float64(-12e4))}, - { "truex", Path{}, Any(true)}, - { "false,", Path{}, Any(false)}, - { `{"a":{,xxx},"b":true}`, Path{"b"}, Any(true)}, - { `{"a":[,xxx],"b":true}`, Path{"b"}, Any(true)}, - } - - for _, test := range tests { - f := func(t *testing.T) { - search := NewSearcher(test.json) - node, err := search.GetByPath(test.path...) - assert.NoError(t, err) - v, err := node.Interface() - assert.NoError(t, err) - assert.Equal(t, v, test.exp) - } - t.Run(test.json, f) - } -} - -func TestGet_InvalidPathType(t *testing.T) { - assert.Panics(t, assert.PanicTestFunc(func() { - data := `{"a":[{"b":true}]}` - s := NewSearcher(data) - s.GetByPath("a", true) - - s = NewSearcher(data) - s.GetByPath("a", nil) - - s = NewSearcher(data) - s.GetByPath("a", -1) - })) -} diff --git a/ast/b64_amd64.go b/ast/b64_amd64.go new file mode 100644 index 000000000..fd3d85e36 --- /dev/null +++ b/ast/b64_amd64.go @@ -0,0 +1,31 @@ +// +build amd64,go1.16 + +/** + * 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 ast + +import ( + `github.com/chenzhuoyu/base64x` +) + +func decodeBase64(src string) ([]byte, error) { + return base64x.StdEncoding.DecodeString(src) +} + +func encodeBase64(src []byte) string { + return base64x.StdEncoding.EncodeToString(src) +} diff --git a/ast/b64_compat.go b/ast/b64_compat.go new file mode 100644 index 000000000..e8f9a72fd --- /dev/null +++ b/ast/b64_compat.go @@ -0,0 +1,31 @@ +// +build !amd64 !go1.16 + +/* + * Copyright 2022 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 ast + +import ( + `encoding/base64` +) + +func decodeBase64(src string) ([]byte, error) { + return base64.StdEncoding.DecodeString(src) +} + +func encodeBase64(src []byte) string { + return base64.StdEncoding.EncodeToString(src) +} diff --git a/ast/encode_test.go b/ast/encode_test.go index 333270732..f4df07f10 100644 --- a/ast/encode_test.go +++ b/ast/encode_test.go @@ -19,9 +19,11 @@ package ast import ( `encoding/json` `runtime` + `strings` `sync` `testing` + `github.com/stretchr/testify/assert` `github.com/stretchr/testify/require` ) @@ -94,12 +96,12 @@ func TestEncodeNode(t *testing.T) { type SortableNode struct { sorted bool - *Node + *Node } func (j *SortableNode) UnmarshalJSON(data []byte) (error) { j.Node = new(Node) - return j.Node.UnmarshalJSON(data) + return j.Node.UnmarshalJSON(data) } func (j *SortableNode) MarshalJSON() ([]byte, error) { @@ -107,7 +109,7 @@ func (j *SortableNode) MarshalJSON() ([]byte, error) { j.Node.SortKeys(true) j.sorted = true } - return j.Node.MarshalJSON() + return j.Node.MarshalJSON() } func TestMarshalSort(t *testing.T) { @@ -203,3 +205,168 @@ func TestEncodeNone(t *testing.T) { require.NoError(t, err) require.Equal(t, `[null]`, string(out)) } + + +type Path = []interface{} + +type testGetApi struct { + json string + path Path +} + +type checkError func(error) bool + +func isSyntaxError(err error) bool { + if err == nil { + return false + } + return strings.HasPrefix(err.Error(), `"Syntax error at index`) +} + +func isEmptySource(err error) bool { + if err == nil { + return false + } + return strings.Contains(err.Error(), "no sources available") +} + +func isErrNotExist(err error) bool { + return err == ErrNotExist +} + +func isErrUnsupportType(err error) bool { + return err == ErrUnsupportType +} + +func testSyntaxJson(t *testing.T, json string, path ...interface{}) { + search := NewSearcher(json) + _, err := search.GetByPath(path...) + assert.True(t, isSyntaxError(err)) +} + +func TestGetFromEmptyJson(t *testing.T) { + tests := []testGetApi { + { "", nil }, + { "", Path{}}, + { "", Path{""}}, + { "", Path{0}}, + { "", Path{"", ""}}, + } + for _, test := range tests { + f := func(t *testing.T) { + search := NewSearcher(test.json) + _, err := search.GetByPath(test.path...) + assert.True(t, isEmptySource(err)) + } + t.Run(test.json, f) + } +} + +func TestGetFromSyntaxError(t *testing.T) { + tests := []testGetApi { + { " \r\n\f\t", Path{} }, + { "123.", Path{} }, + { "+124", Path{} }, + { "-", Path{} }, + { "-e123", Path{} }, + { "-1.e123", Path{} }, + { "-12e456.1", Path{} }, + { "-12e.1", Path{} }, + { "[", Path{} }, + { "{", Path{} }, + { "[}", Path{} }, + { "{]", Path{} }, + { "{,}", Path{} }, + { "[,]", Path{} }, + { "tru", Path{} }, + { "fals", Path{} }, + { "nul", Path{} }, + { `{"a":"`, Path{"a"} }, + { `{"`, Path{} }, + { `"`, Path{} }, + { `"\"`, Path{} }, + { `"\\\"`, Path{} }, + { `"hello`, Path{} }, + { `{{}}`, Path{} }, + { `{[]}`, Path{} }, + { `{:,}`, Path{} }, + { `{test:error}`, Path{} }, + { `{":true}`, Path{} }, + { `{"" false}`, Path{} }, + { `{ "" : "false }`, Path{} }, + { `{"":"",}`, Path{} }, + { `{ " test : true}`, Path{} }, + { `{ "test" : tru }`, Path{} }, + { `{ "test" : true , }`, Path{} }, + { `{ {"test" : true , } }`, Path{} }, + { `{"test":1. }`, Path{} }, + { `{"\\\""`, Path{} }, + { `{"\\\"":`, Path{} }, + { `{"\\\":",""}`, Path{} }, + { `[{]`, Path{} }, + { `[tru]`, Path{} }, + { `[-1.]`, Path{} }, + { `[[]`, Path{} }, + { `[[],`, Path{} }, + { `[ true , false , [ ]`, Path{} }, + { `[true, false, [],`, Path{} }, + { `[true, false, [],]`, Path{} }, + { `{"key": [true, false, []], "key2": {{}}`, Path{} }, + } + + for _, test := range tests { + f := func(t *testing.T) { + testSyntaxJson(t, test.json, test.path...) + path := append(Path{"key"}, test.path...) + testSyntaxJson(t, `{"key":` + test.json, path...) + path = append(Path{""}, test.path...) + testSyntaxJson(t, `{"":` + test.json, path...) + path = append(Path{1}, test.path...) + testSyntaxJson(t, `["",` + test.json, path...) + } + t.Run(test.json, f) + } +} + +// NOTE: GetByPath API not validate the undemanded fields for performance. +func TestGetWithInvalidUndemandedField(t *testing.T) { + type Any = interface{} + tests := []struct { + json string + path Path + exp Any + } { + { "-0xyz", Path{}, Any(float64(-0))}, + { "-12e4xyz", Path{}, Any(float64(-12e4))}, + { "truex", Path{}, Any(true)}, + { "false,", Path{}, Any(false)}, + { `{"a":{,xxx},"b":true}`, Path{"b"}, Any(true)}, + { `{"a":[,xxx],"b":true}`, Path{"b"}, Any(true)}, + } + + for _, test := range tests { + f := func(t *testing.T) { + search := NewSearcher(test.json) + node, err := search.GetByPath(test.path...) + assert.NoError(t, err) + v, err := node.Interface() + assert.NoError(t, err) + assert.Equal(t, v, test.exp) + } + t.Run(test.json, f) + } +} + +func TestGet_InvalidPathType(t *testing.T) { + assert.Panics(t, assert.PanicTestFunc(func() { + data := `{"a":[{"b":true}]}` + s := NewSearcher(data) + s.GetByPath("a", true) + + s = NewSearcher(data) + s.GetByPath("a", nil) + + s = NewSearcher(data) + s.GetByPath("a", -1) + })) +} diff --git a/ast/node_test.go b/ast/node_test.go index b771dada0..b8e9c7622 100644 --- a/ast/node_test.go +++ b/ast/node_test.go @@ -22,8 +22,6 @@ import ( `errors` `fmt` `reflect` - `runtime` - `runtime/debug` `strconv` `testing` @@ -138,23 +136,6 @@ func stackObj() interface{} { return rt.UnpackEface(a).Pack() } -func TestStackAny(t *testing.T) { - var obj = stackObj() - any := NewAny(obj) - fmt.Printf("any: %#v\n", any) - runtime.GC() - debug.FreeOSMemory() - println("finish GC") - buf, err := any.MarshalJSON() - println("finish marshal") - if err != nil { - t.Fatal(err) - } - if string(buf) != `1` { - t.Fatal(string(buf)) - } -} - func TestLoadAll(t *testing.T) { e := Node{} err := e.Load() @@ -328,7 +309,6 @@ func TestTypeCast(t *testing.T) { {"ArrayUseNumber", NewAny([]Node{NewNumber("1")}), []interface{}(nil), ErrUnsupportType}, {"ArrayUseNumber", NewArray([]Node{NewNumber("1")}), []interface{}{json.Number("1")}, nil}, {"Raw", Node{}, "", ErrNotExist}, - {"Raw", NewAny(""), `""`, nil}, {"Raw", NewRaw(" "), "", nonEmptyErr}, {"Raw", NewRaw(" [ ] "), "[ ]", nil}, {"Raw", NewRaw("[ ]"), "[ ]", nil}, @@ -546,18 +526,16 @@ func TestTypeCast(t *testing.T) { m := rt.MethodByName(c.method) rets := m.Call([]reflect.Value{}) if len(rets) != 2 { - t.Error(i, rets) - } - if !reflect.DeepEqual(rets[0].Interface(), c.exp) { - t.Error(i, rets[0].Interface(), c.exp) + t.Fatal(i, rets) } - v := rets[1].Interface() + assert.Equal(t, rets[0].Interface(), c.exp) + v := rets[1].Interface(); if c.err == nonEmptyErr { if reflect.ValueOf(v).IsNil() { - t.Error(i, v) + t.Fatal(i, v) } - } else if v != c.err { - t.Error(i, v) + } else if v != c.err { + t.Fatal(i, v) } } } @@ -1325,43 +1303,6 @@ func TestNodeSet(t *testing.T) { } } -func TestNodeAny(t *testing.T) { - empty := Node{} - _, err := empty.SetAny("any", map[string]interface{}{"a": []int{0}}) - if err != nil { - t.Fatal(err) - } - if m, err := empty.Get("any").Interface(); err != nil { - t.Fatal(err) - } else if v, ok := m.(map[string]interface{}); !ok { - t.Fatal(v) - } - if buf, err := empty.MarshalJSON(); err != nil { - t.Fatal(err) - } else if string(buf) != `{"any":{"a":[0]}}` { - t.Fatal(string(buf)) - } - if _, err := empty.Set("any2", Node{}); err != nil { - t.Fatal(err) - } - if err := empty.Get("any2").AddAny(nil); err != nil { - t.Fatal(err) - } - if buf, err := empty.MarshalJSON(); err != nil { - t.Fatal(err) - } else if string(buf) != `{"any":{"a":[0]},"any2":[null]}` { - t.Fatal(string(buf)) - } - if _, err := empty.Get("any2").SetAnyByIndex(0, NewNumber("-0.0")); err != nil { - t.Fatal(err) - } - if buf, err := empty.MarshalJSON(); err != nil { - t.Fatal(err) - } else if string(buf) != `{"any":{"a":[0]},"any2":[-0.0]}` { - t.Fatal(string(buf)) - } -} - func TestNodeSetByIndex(t *testing.T) { root, derr := NewParser(_TwitterJson).Parse() if derr != 0 { diff --git a/compat_test.go b/compat_test.go index 0c8b0bee1..fe23e19bd 100644 --- a/compat_test.go +++ b/compat_test.go @@ -171,18 +171,18 @@ func TestPretouch(t *testing.T) { } } -func TestGet(t *testing.T) { - var data = `{"a":"b"}` - r, err := GetFromString(data, "a") - if err != nil { - t.Fatal(err) - } - v, err := r.String() - if err != nil { - t.Fatal(err) - } - if v != "b" { - t.Fatal(v) - } -} +// func TestGet(t *testing.T) { +// var data = `{"a":"b"}` +// r, err := GetFromString(data, "a") +// if err != nil { +// t.Fatal(err) +// } +// v, err := r.String() +// if err != nil { +// t.Fatal(err) +// } +// if v != "b" { +// t.Fatal(v) +// } +// } diff --git a/internal/decoder/decoder_test.go b/internal/decoder/decoder_test.go index f9c86e2b0..120d8b590 100644 --- a/internal/decoder/decoder_test.go +++ b/internal/decoder/decoder_test.go @@ -400,163 +400,3 @@ func TestDecoder_MapWithIndirectElement(t *testing.T) { require.NoError(t, err) assert.Equal(t, [129]byte{1, 2, 3, 4, 5}, v[""].A) } - -func BenchmarkDecoder_Generic_Sonic(b *testing.B) { - var w interface{} - _, _ = decode(TwitterJson, &w, true) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - for i := 0; i < b.N; i++ { - var v interface{} - _, _ = decode(TwitterJson, &v, true) - } -} - -func BenchmarkDecoder_Generic_Sonic_Fast(b *testing.B) { - var w interface{} - _, _ = decode(TwitterJson, &w, false) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - for i := 0; i < b.N; i++ { - var v interface{} - _, _ = decode(TwitterJson, &v, false) - } -} - -func BenchmarkDecoder_Generic_StdLib(b *testing.B) { - var w interface{} - m := []byte(TwitterJson) - _ = json.Unmarshal(m, &w) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - for i := 0; i < b.N; i++ { - var v interface{} - _ = json.Unmarshal(m, &v) - } -} - -func BenchmarkDecoder_Binding_Sonic(b *testing.B) { - var w TwitterStruct - _, _ = decode(TwitterJson, &w, true) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - for i := 0; i < b.N; i++ { - var v TwitterStruct - _, _ = decode(TwitterJson, &v, true) - } -} - -func BenchmarkDecoder_Binding_Sonic_Fast(b *testing.B) { - var w TwitterStruct - _, _ = decode(TwitterJson, &w, false) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - for i := 0; i < b.N; i++ { - var v TwitterStruct - _, _ = decode(TwitterJson, &v, false) - } -} - -func BenchmarkDecoder_Binding_StdLib(b *testing.B) { - var w TwitterStruct - m := []byte(TwitterJson) - _ = json.Unmarshal(m, &w) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - for i := 0; i < b.N; i++ { - var v TwitterStruct - _ = json.Unmarshal(m, &v) - } -} - -func BenchmarkDecoder_Parallel_Generic_Sonic(b *testing.B) { - var w interface{} - _, _ = decode(TwitterJson, &w, true) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - b.RunParallel(func(pb *testing.PB) { - for pb.Next() { - var v interface{} - _, _ = decode(TwitterJson, &v, true) - } - }) -} - -func BenchmarkDecoder_Parallel_Generic_Sonic_Fast(b *testing.B) { - var w interface{} - _, _ = decode(TwitterJson, &w, false) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - b.RunParallel(func(pb *testing.PB) { - for pb.Next() { - var v interface{} - _, _ = decode(TwitterJson, &v, false) - } - }) -} - -func BenchmarkDecoder_Parallel_Generic_StdLib(b *testing.B) { - var w interface{} - m := []byte(TwitterJson) - _ = json.Unmarshal(m, &w) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - b.RunParallel(func(pb *testing.PB) { - for pb.Next() { - var v interface{} - _ = json.Unmarshal(m, &v) - } - }) -} - -func BenchmarkDecoder_Parallel_Binding_Sonic(b *testing.B) { - var w TwitterStruct - _, _ = decode(TwitterJson, &w, true) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - b.RunParallel(func(pb *testing.PB) { - for pb.Next() { - var v TwitterStruct - _, _ = decode(TwitterJson, &v, true) - } - }) -} - -func BenchmarkDecoder_Parallel_Binding_Sonic_Fast(b *testing.B) { - var w TwitterStruct - _, _ = decode(TwitterJson, &w, false) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - b.RunParallel(func(pb *testing.PB) { - for pb.Next() { - var v TwitterStruct - _, _ = decode(TwitterJson, &v, false) - } - }) -} - -func BenchmarkDecoder_Parallel_Binding_StdLib(b *testing.B) { - var w TwitterStruct - m := []byte(TwitterJson) - _ = json.Unmarshal(m, &w) - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - b.RunParallel(func(pb *testing.PB) { - for pb.Next() { - var v TwitterStruct - _ = json.Unmarshal(m, &v) - } - }) -} - -func BenchmarkSkip_Sonic(b *testing.B) { - var data = rt.Str2Mem(TwitterJson) - if ret, _ := Skip(data); ret < 0 { - b.Fatal() - } - b.SetBytes(int64(len(TwitterJson))) - b.ResetTimer() - for i:=0; i(SB) + JMP _entry diff --git a/internal/native/neon/f32toa_subr_arm64.go b/internal/native/neon/f32toa_subr_arm64.go new file mode 100644 index 000000000..e57cb74f4 --- /dev/null +++ b/internal/native/neon/f32toa_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __f32toa_arm64_entry__() uintptr + +var ( + _subr__f32toa uintptr = __f32toa_arm64_entry__() + 12 +) + +const ( + _stack__f32toa = 32 +) + +var ( + _ = _subr__f32toa +) + +const ( + _ = _stack__f32toa +) diff --git a/internal/native/neon/f64toa_arm64.go b/internal/native/neon/f64toa_arm64.go new file mode 100644 index 000000000..169924be5 --- /dev/null +++ b/internal/native/neon/f64toa_arm64.go @@ -0,0 +1,31 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +//go:nosplit +func f64toa(out *byte, val float64) (ret int) { + return __f64toa(out, val) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __f64toa(out *byte, val float64) (ret int) diff --git a/internal/native/neon/f64toa_arm64.s b/internal/native/neon/f64toa_arm64.s new file mode 100644 index 000000000..aec60538d --- /dev/null +++ b/internal/native/neon/f64toa_arm64.s @@ -0,0 +1,2466 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__f64toa_arm64_entry__(SB), NOSPLIT, $32 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_f64toa: + MOVD.W R30, -48(RSP) // WORD $0xf81d0ffe // str x30, [sp, #-48]! + WORD $0xa9024ff4 // stp x20, x19, [sp, #32] + WORD $0x9e66000a // fmov x10, d0 + WORD $0xd374f94b // ubfx x11, x10, #52, #11 + WORD $0x711ffd7f // cmp w11, #2047 + WORD $0x540079c0 // b.eq LBB0_163 $3896(%rip) + WORD $0x528005a8 // mov w8, #45 + WORD $0x39000008 // strb w8, [x0] + WORD $0xd37ffd49 // lsr x9, x10, #63 + WORD $0x8b090008 // add x8, x0, x9 + WORD $0xf240f95f // tst x10, #0x7fffffffffffffff + WORD $0x54000ee0 // b.eq LBB0_10 $476(%rip) + WORD $0x9240cd4d // and x13, x10, #0xfffffffffffff + WORD $0x34007a2b // cbz w11, LBB0_166 $3908(%rip) + WORD $0xb24c01aa // orr x10, x13, #0x10000000000000 + WORD $0x5110cd6c // sub w12, w11, #1075 + WORD $0x510ffd6e // sub w14, w11, #1023 + WORD $0x7100d1df // cmp w14, #52 + WORD $0x540000e8 // b.hi LBB0_5 $28(%rip) + WORD $0x5280866e // mov w14, #1075 + WORD $0x4b0b01ce // sub w14, w14, w11 + WORD $0x9280000f // mov x15, #-1 + WORD $0x9ace21ef // lsl x15, x15, x14 + WORD $0xea2f015f // bics xzr, x10, x15 + WORD $0x540010c0 // b.eq LBB0_18 $536(%rip) +LBB0_5: + WORD $0xf10001bf // cmp x13, #0 + WORD $0x1a9f17ed // cset w13, eq + WORD $0x7100057f // cmp w11, #1 + WORD $0x1a9f97eb // cset w11, hi + WORD $0xd37ef54e // lsl x14, x10, #2 + WORD $0x6a0b01ab // ands w11, w13, w11 + WORD $0xaa0b01cb // orr x11, x14, x11 + WORD $0x5280004d // mov w13, #2 + WORD $0xb37ed14d // bfi x13, x10, #2, #53 + WORD $0x5288826f // mov w15, #17427 + WORD $0x72a0026f // movk w15, #19, lsl #16 + WORD $0x52802030 // mov w16, #257 + WORD $0x72bfff10 // movk w16, #65528, lsl #16 + WORD $0x1a9f1210 // csel w16, w16, wzr, ne + WORD $0xd1000971 // sub x17, x11, #2 + WORD $0x1b0f418b // madd w11, w12, w15, w16 + WORD $0x13167d6b // asr w11, w11, #22 + WORD $0x528d962f // mov w15, #27825 + WORD $0x72bffcaf // movk w15, #65509, lsl #16 + WORD $0x1b0f7d6f // mul w15, w11, w15 + WORD $0x0b8f4d8c // add w12, w12, w15, asr #19 + WORD $0x1100058f // add w15, w12, #1 + WORD $0x5280248c // mov w12, #292 + WORD $0x4b0b018c // sub w12, w12, w11 +Lloh0: + WORD $0x10007e50 // adr x16, _pow10_ceil_sig.g $4040(%rip) +Lloh1: + WORD $0x91000210 // add x16, x16, _pow10_ceil_sig.g@PAGEOFF $0(%rip) + WORD $0x8b2c520c // add x12, x16, w12, uxtw #4 + WORD $0xa9400590 // ldp x16, x1, [x12] + WORD $0x9acf222c // lsl x12, x17, x15 + WORD $0x9bd07d91 // umulh x17, x12, x16 + WORD $0x9b107d82 // mul x2, x12, x16 + WORD $0x9bc17d8c // umulh x12, x12, x1 + WORD $0xab02018c // adds x12, x12, x2 + WORD $0xba1f0231 // adcs x17, x17, xzr + WORD $0xf27ff99f // tst x12, #0xfffffffffffffffe + WORD $0x1a9f07ec // cset w12, ne + WORD $0xaa110191 // orr x17, x12, x17 + WORD $0x9acf21cc // lsl x12, x14, x15 + WORD $0x9bd07d8e // umulh x14, x12, x16 + WORD $0x9b107d82 // mul x2, x12, x16 + WORD $0x9bc17d8c // umulh x12, x12, x1 + WORD $0xab020182 // adds x2, x12, x2 + WORD $0xba1f01cc // adcs x12, x14, xzr + WORD $0xf27ff85f // tst x2, #0xfffffffffffffffe + WORD $0x1a9f07ee // cset w14, ne + WORD $0xaa0c01ce // orr x14, x14, x12 + WORD $0x9acf21ad // lsl x13, x13, x15 + WORD $0x9bd07daf // umulh x15, x13, x16 + WORD $0x9b107db0 // mul x16, x13, x16 + WORD $0x9bc17dad // umulh x13, x13, x1 + WORD $0xab1001ad // adds x13, x13, x16 + WORD $0xba1f01ef // adcs x15, x15, xzr + WORD $0xf27ff9bf // tst x13, #0xfffffffffffffffe + WORD $0x1a9f07ed // cset w13, ne + WORD $0xaa0f01ad // orr x13, x13, x15 + WORD $0x9240014a // and x10, x10, #0x1 + WORD $0x8b0a022f // add x15, x17, x10 + WORD $0xcb0a01aa // sub x10, x13, x10 + WORD $0xf100a1df // cmp x14, #40 + WORD $0x540001e3 // b.lo LBB0_7 $60(%rip) + WORD $0xb202e7ed // mov x13, #-3689348814741910324 + WORD $0xf29999ad // movk x13, #52429 + WORD $0x9bcd7d8d // umulh x13, x12, x13 + WORD $0xd345fdad // lsr x13, x13, #5 + WORD $0x8b0d09b0 // add x16, x13, x13, lsl #2 + WORD $0xd37df210 // lsl x16, x16, #3 + WORD $0xeb1001ff // cmp x15, x16 + WORD $0x1a9f97f1 // cset w17, hi + WORD $0x9100a210 // add x16, x16, #40 + WORD $0xeb0a021f // cmp x16, x10 + WORD $0x1a9f87f0 // cset w16, ls + WORD $0x9a8d85ad // cinc x13, x13, ls + WORD $0x6b10023f // cmp w17, w16 + WORD $0x540004e0 // b.eq LBB0_11 $156(%rip) +LBB0_7: + WORD $0xd342fd8d // lsr x13, x12, #2 + WORD $0x927ef590 // and x16, x12, #0xfffffffffffffffc + WORD $0xeb1001ff // cmp x15, x16 + WORD $0x1a9f97ef // cset w15, hi + WORD $0x91001211 // add x17, x16, #4 + WORD $0xeb0a023f // cmp x17, x10 + WORD $0x1a9f87e1 // cset w1, ls + WORD $0x4a0101ef // eor w15, w15, w1 + WORD $0xb27f0210 // orr x16, x16, #0x2 + WORD $0xeb1001df // cmp x14, x16 + WORD $0x1a9f97ee // cset w14, hi + WORD $0x1a9f17f0 // cset w16, eq + WORD $0x0a4c0a0c // and w12, w16, w12, lsr #2 + WORD $0x2a0c01cc // orr w12, w14, w12 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xeb0a023f // cmp x17, x10 + WORD $0x9a8d85aa // cinc x10, x13, ls + WORD $0x720001ff // tst w15, #0x1 + WORD $0x9a8a118d // csel x13, x12, x10, ne + WORD $0xd29c7fea // mov x10, #58367 + WORD $0xf2aa816a // movk x10, #21515, lsl #16 + WORD $0xf2c0004a // movk x10, #2, lsl #32 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x540002a9 // b.ls LBB0_12 $84(%rip) +LBB0_8: + WORD $0xd29d000a // mov x10, #59392 + WORD $0xf2a90eca // movk x10, #18550, lsl #16 + WORD $0xf2c002ea // movk x10, #23, lsl #32 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54000282 // b.hs LBB0_14 $80(%rip) + WORD $0x5280016c // mov w12, #11 + WORD $0x1400009e // b LBB0_59 $632(%rip) +LBB0_10: + WORD $0x52800609 // mov w9, #48 + WORD $0x39000109 // strb w9, [x8] + WORD $0x4b000108 // sub w8, w8, w0 + WORD $0x11000500 // add w0, w8, #1 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_11: + WORD $0x1100056b // add w11, w11, #1 + WORD $0xd29c7fea // mov x10, #58367 + WORD $0xf2aa816a // movk x10, #21515, lsl #16 + WORD $0xf2c0004a // movk x10, #2, lsl #32 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54fffda8 // b.hi LBB0_8 $-76(%rip) +LBB0_12: + WORD $0xf10029bf // cmp x13, #10 + WORD $0x54000142 // b.hs LBB0_16 $40(%rip) + WORD $0x5280002c // mov w12, #1 + WORD $0x1400008d // b LBB0_59 $564(%rip) +LBB0_14: + WORD $0xd282000a // mov x10, #4096 + WORD $0xf2ba94aa // movk x10, #54437, lsl #16 + WORD $0xf2c01d0a // movk x10, #232, lsl #32 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x540002c2 // b.hs LBB0_21 $88(%rip) + WORD $0x5280018c // mov w12, #12 + WORD $0x14000086 // b LBB0_59 $536(%rip) +LBB0_16: + WORD $0xf10191bf // cmp x13, #100 + WORD $0x54000322 // b.hs LBB0_23 $100(%rip) + WORD $0x5280004c // mov w12, #2 + WORD $0x14000082 // b LBB0_59 $520(%rip) +LBB0_18: + WORD $0x9ace254a // lsr x10, x10, x14 + WORD $0xd29c7feb // mov x11, #58367 + WORD $0xf2aa816b // movk x11, #21515, lsl #16 + WORD $0xf2c0004b // movk x11, #2, lsl #32 +Lloh2: + WORD $0x100069e9 // adr x9, _Digits $3388(%rip) +Lloh3: + WORD $0x91000129 // add x9, x9, _Digits@PAGEOFF $0(%rip) + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x54000269 // b.ls LBB0_25 $76(%rip) + WORD $0xd29d000b // mov x11, #59392 + WORD $0xf2a90ecb // movk x11, #18550, lsl #16 + WORD $0xf2c002eb // movk x11, #23, lsl #32 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x540003e2 // b.hs LBB0_31 $124(%rip) + WORD $0x5280016b // mov w11, #11 + WORD $0x140002b9 // b LBB0_149 $2788(%rip) +LBB0_21: + WORD $0xd294000a // mov x10, #40960 + WORD $0xf2a9ce4a // movk x10, #20082, lsl #16 + WORD $0xf2c1230a // movk x10, #2328, lsl #32 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54000182 // b.hs LBB0_27 $48(%rip) + WORD $0x528001ac // mov w12, #13 + WORD $0x1400006c // b LBB0_59 $432(%rip) +LBB0_23: + WORD $0xf10fa1bf // cmp x13, #1000 + WORD $0x540001e2 // b.hs LBB0_29 $60(%rip) + WORD $0x5280006c // mov w12, #3 + WORD $0x14000068 // b LBB0_59 $416(%rip) +LBB0_25: + WORD $0xf100295f // cmp x10, #10 + WORD $0x540002e2 // b.hs LBB0_33 $92(%rip) + WORD $0x5280002b // mov w11, #1 + WORD $0x8b0b010b // add x11, x8, x11 + WORD $0x1400032d // b LBB0_168 $3252(%rip) +LBB0_27: + WORD $0xd288000a // mov x10, #16384 + WORD $0xf2a20f4a // movk x10, #4218, lsl #16 + WORD $0xf2cb5e6a // movk x10, #23283, lsl #32 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54000282 // b.hs LBB0_35 $80(%rip) + WORD $0x528001cc // mov w12, #14 + WORD $0x1400005c // b LBB0_59 $368(%rip) +LBB0_29: + WORD $0xd344fdaa // lsr x10, x13, #4 + WORD $0xf109c55f // cmp x10, #625 + WORD $0x540002c2 // b.hs LBB0_37 $88(%rip) + WORD $0x5280008c // mov w12, #4 + WORD $0x14000057 // b LBB0_59 $348(%rip) +LBB0_31: + WORD $0xd282000b // mov x11, #4096 + WORD $0xf2ba94ab // movk x11, #54437, lsl #16 + WORD $0xf2c01d0b // movk x11, #232, lsl #32 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x54000282 // b.hs LBB0_39 $80(%rip) + WORD $0x5280018b // mov w11, #12 + WORD $0x14000296 // b LBB0_149 $2648(%rip) +LBB0_33: + WORD $0xf101915f // cmp x10, #100 + WORD $0x540002e2 // b.hs LBB0_41 $92(%rip) + WORD $0x5280004b // mov w11, #2 + WORD $0x8b0b010b // add x11, x8, x11 + WORD $0x14000315 // b LBB0_168 $3156(%rip) +LBB0_35: + WORD $0xb2718bea // mov x10, #1125899906809856 + WORD $0xf2b498ca // movk x10, #42182, lsl #16 + WORD $0xf2d1afca // movk x10, #36222, lsl #32 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54000282 // b.hs LBB0_43 $80(%rip) + WORD $0x528001ec // mov w12, #15 + WORD $0x14000044 // b LBB0_59 $272(%rip) +LBB0_37: + WORD $0xd345fdaa // lsr x10, x13, #5 + WORD $0xf130d55f // cmp x10, #3125 + WORD $0x540002c2 // b.hs LBB0_45 $88(%rip) + WORD $0x528000ac // mov w12, #5 + WORD $0x1400003f // b LBB0_59 $252(%rip) +LBB0_39: + WORD $0xd294000b // mov x11, #40960 + WORD $0xf2a9ce4b // movk x11, #20082, lsl #16 + WORD $0xf2c1230b // movk x11, #2328, lsl #32 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x540002a2 // b.hs LBB0_47 $84(%rip) + WORD $0x528001ab // mov w11, #13 + WORD $0x1400027e // b LBB0_149 $2552(%rip) +LBB0_41: + WORD $0xf10fa15f // cmp x10, #1000 + WORD $0x54000302 // b.hs LBB0_49 $96(%rip) + WORD $0x5280006b // mov w11, #3 + WORD $0x8b0b010b // add x11, x8, x11 + WORD $0x140002fd // b LBB0_168 $3060(%rip) +LBB0_43: + WORD $0xd2adf82a // mov x10, #1874919424 + WORD $0xf2d0de4a // movk x10, #34546, lsl #32 + WORD $0xf2e0046a // movk x10, #35, lsl #48 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x5280020a // mov w10, #16 +LBB0_44: + WORD $0x1a8a354c // cinc w12, w10, hs + WORD $0x1400002c // b LBB0_59 $176(%rip) +LBB0_45: + WORD $0x5288480a // mov w10, #16960 + WORD $0x72a001ea // movk w10, #15, lsl #16 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54000202 // b.hs LBB0_51 $64(%rip) + WORD $0x528000cc // mov w12, #6 + WORD $0x14000026 // b LBB0_59 $152(%rip) +LBB0_47: + WORD $0xd288000b // mov x11, #16384 + WORD $0xf2a20f4b // movk x11, #4218, lsl #16 + WORD $0xf2cb5e6b // movk x11, #23283, lsl #32 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x540001e2 // b.hs LBB0_53 $60(%rip) + WORD $0x528001cb // mov w11, #14 + WORD $0x14000265 // b LBB0_149 $2452(%rip) +LBB0_49: + WORD $0xd344fd4b // lsr x11, x10, #4 + WORD $0xf109c57f // cmp x11, #625 + WORD $0x54000222 // b.hs LBB0_55 $68(%rip) + WORD $0x5280008b // mov w11, #4 + WORD $0x8b0b010b // add x11, x8, x11 + WORD $0x140002e3 // b LBB0_168 $2956(%rip) +LBB0_51: + WORD $0x5292d00a // mov w10, #38528 + WORD $0x72a0130a // movk w10, #152, lsl #16 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54000202 // b.hs LBB0_57 $64(%rip) + WORD $0x528000ec // mov w12, #7 + WORD $0x14000013 // b LBB0_59 $76(%rip) +LBB0_53: + WORD $0xb2718beb // mov x11, #1125899906809856 + WORD $0xf2b498cb // movk x11, #42182, lsl #16 + WORD $0xf2d1afcb // movk x11, #36222, lsl #32 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x540049c2 // b.hs LBB0_148 $2360(%rip) + WORD $0x528001eb // mov w11, #15 + WORD $0x14000252 // b LBB0_149 $2376(%rip) +LBB0_55: + WORD $0xd345fd4b // lsr x11, x10, #5 + WORD $0xf130d57f // cmp x11, #3125 + WORD $0x54005542 // b.hs LBB0_158 $2728(%rip) + WORD $0x528000ab // mov w11, #5 + WORD $0x8b0b010b // add x11, x8, x11 + WORD $0x140002d0 // b LBB0_168 $2880(%rip) +LBB0_57: + WORD $0x529c200a // mov w10, #57600 + WORD $0x72a0beaa // movk w10, #1525, lsl #16 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54005542 // b.hs LBB0_160 $2728(%rip) + WORD $0x5280010c // mov w12, #8 +LBB0_59: + WORD $0x0b0b018a // add w10, w12, w11 + WORD $0x5100594e // sub w14, w10, #22 + WORD $0x310071df // cmn w14, #28 + WORD $0x54000188 // b.hi LBB0_63 $48(%rip) + WORD $0x9100050b // add x11, x8, #1 + WORD $0x2a0c03ec // mov w12, w12 + WORD $0x8b0c016e // add x14, x11, x12 + WORD $0xd360fdaf // lsr x15, x13, #32 + WORD $0xb500024f // cbnz x15, LBB0_67 $72(%rip) + WORD $0xaa0d03f0 // mov x16, x13 + WORD $0x53047e0d // lsr w13, w16, #4 + WORD $0x7109c5bf // cmp w13, #625 + WORD $0x540017c2 // b.hs LBB0_86 $760(%rip) +LBB0_62: + WORD $0xaa1003ed // mov x13, x16 + WORD $0x140000d3 // b LBB0_88 $844(%rip) +LBB0_63: + WORD $0x37f8074b // tbnz w11, #31, LBB0_69 $232(%rip) + WORD $0x2a0c03ec // mov w12, w12 + WORD $0x8b0c010b // add x11, x8, x12 + WORD $0xd360fdae // lsr x14, x13, #32 + WORD $0xb500082e // cbnz x14, LBB0_73 $260(%rip) + WORD $0xaa0b03ee // mov x14, x11 + WORD $0x53047daf // lsr w15, w13, #4 + WORD $0x7109c5ff // cmp w15, #625 + WORD $0x54000d42 // b.hs LBB0_74 $424(%rip) +LBB0_66: + WORD $0xaa0d03ef // mov x15, x13 + WORD $0x1400007f // b LBB0_76 $508(%rip) +LBB0_67: + WORD $0xd299dfaf // mov x15, #52989 + WORD $0xf2b08c2f // movk x15, #33889, lsl #16 + WORD $0xf2cee22f // movk x15, #30481, lsl #32 + WORD $0xf2f5798f // movk x15, #43980, lsl #48 + WORD $0x9bcf7daf // umulh x15, x13, x15 + WORD $0xd35afdf0 // lsr x16, x15, #26 + WORD $0x5283e00f // mov w15, #7936 + WORD $0x72bf414f // movk w15, #64010, lsl #16 + WORD $0x1b0f360d // madd w13, w16, w15, w13 + WORD $0x3400144d // cbz w13, LBB0_85 $648(%rip) + WORD $0xd280000f // mov x15, #0 + WORD $0x5282eb31 // mov w17, #5977 + WORD $0x72ba36f1 // movk w17, #53687, lsl #16 + WORD $0x9bb17da1 // umull x1, w13, w17 + WORD $0xd36dfc21 // lsr x1, x1, #45 + WORD $0x5284e202 // mov w2, #10000 + WORD $0x1b02b42d // msub w13, w1, w2, w13 + WORD $0x9b117c31 // mul x17, x1, x17 + WORD $0xd36dfe31 // lsr x17, x17, #45 + WORD $0x1b028631 // msub w17, w17, w2, w1 + WORD $0x53023da1 // ubfx w1, w13, #2, #14 + WORD $0x52828f62 // mov w2, #5243 + WORD $0x1b027c21 // mul w1, w1, w2 + WORD $0x53117c21 // lsr w1, w1, #17 + WORD $0x53023e23 // ubfx w3, w17, #2, #14 + WORD $0x1b027c62 // mul w2, w3, w2 + WORD $0x52800c83 // mov w3, #100 + WORD $0x1b03b42d // msub w13, w1, w3, w13 + WORD $0x92403dad // and x13, x13, #0xffff + WORD $0x53117c42 // lsr w2, w2, #17 + WORD $0x1b03c451 // msub w17, w2, w3, w17 + WORD $0x92403e31 // and x17, x17, #0xffff +Lloh4: + WORD $0x10005303 // adr x3, _Digits $2656(%rip) +Lloh5: + WORD $0x91000063 // add x3, x3, _Digits@PAGEOFF $0(%rip) + WORD $0x786d786d // ldrh w13, [x3, x13, lsl #1] + WORD $0x781fe1cd // sturh w13, [x14, #-2] + WORD $0x7861586d // ldrh w13, [x3, w1, uxtw #1] + WORD $0x781fc1cd // sturh w13, [x14, #-4] + WORD $0x7871786d // ldrh w13, [x3, x17, lsl #1] + WORD $0x781fa1cd // sturh w13, [x14, #-6] + WORD $0x7862586d // ldrh w13, [x3, w2, uxtw #1] + WORD $0x781f81cd // sturh w13, [x14, #-8] + WORD $0xd10021ce // sub x14, x14, #8 + WORD $0x53047e0d // lsr w13, w16, #4 + WORD $0x7109c5bf // cmp w13, #625 + WORD $0x54fff8c3 // b.lo LBB0_62 $-232(%rip) + WORD $0x14000082 // b LBB0_86 $520(%rip) +LBB0_69: + WORD $0x7100015f // cmp w10, #0 + WORD $0x5400254c // b.gt LBB0_116 $1192(%rip) + WORD $0x5285c60e // mov w14, #11824 + WORD $0x7800250e // strh w14, [x8], #2 + WORD $0x36f824ea // tbz w10, #31, LBB0_116 $1180(%rip) + WORD $0x2a2c03ee // mvn w14, w12 + WORD $0x4b0b01ce // sub w14, w14, w11 + WORD $0x71007ddf // cmp w14, #31 + WORD $0x54002202 // b.hs LBB0_111 $1088(%rip) + WORD $0x5280000e // mov w14, #0 + WORD $0x1400011b // b LBB0_114 $1132(%rip) +LBB0_73: + WORD $0xd299dfae // mov x14, #52989 + WORD $0xf2b08c2e // movk x14, #33889, lsl #16 + WORD $0xf2cee22e // movk x14, #30481, lsl #32 + WORD $0xf2f5798e // movk x14, #43980, lsl #48 + WORD $0x9bce7dae // umulh x14, x13, x14 + WORD $0xd35afdcf // lsr x15, x14, #26 + WORD $0x5283e00e // mov w14, #7936 + WORD $0x72bf414e // movk w14, #64010, lsl #16 + WORD $0x1b0e35ed // madd w13, w15, w14, w13 + WORD $0x5282eb2e // mov w14, #5977 + WORD $0x72ba36ee // movk w14, #53687, lsl #16 + WORD $0x9bae7db0 // umull x16, w13, w14 + WORD $0xd36dfe10 // lsr x16, x16, #45 + WORD $0x5284e211 // mov w17, #10000 + WORD $0x1b11b60d // msub w13, w16, w17, w13 + WORD $0x9b0e7e0e // mul x14, x16, x14 + WORD $0xd36dfdce // lsr x14, x14, #45 + WORD $0x1b11c1ce // msub w14, w14, w17, w16 + WORD $0x53023db0 // ubfx w16, w13, #2, #14 + WORD $0x52828f71 // mov w17, #5243 + WORD $0x1b117e10 // mul w16, w16, w17 + WORD $0x53117e10 // lsr w16, w16, #17 + WORD $0x52800c81 // mov w1, #100 + WORD $0x1b01b60d // msub w13, w16, w1, w13 + WORD $0x92403dad // and x13, x13, #0xffff + WORD $0x53023dc2 // ubfx w2, w14, #2, #14 + WORD $0x1b117c51 // mul w17, w2, w17 + WORD $0x53117e31 // lsr w17, w17, #17 + WORD $0x1b01ba2e // msub w14, w17, w1, w14 +Lloh6: + WORD $0x10004c21 // adr x1, _Digits $2436(%rip) +Lloh7: + WORD $0x91000021 // add x1, x1, _Digits@PAGEOFF $0(%rip) + WORD $0x786d782d // ldrh w13, [x1, x13, lsl #1] + WORD $0x78715831 // ldrh w17, [x1, w17, uxtw #1] + WORD $0x92403dc2 // and x2, x14, #0xffff + WORD $0xaa0b03ee // mov x14, x11 + WORD $0x781f8dd1 // strh w17, [x14, #-8]! + WORD $0x78705830 // ldrh w16, [x1, w16, uxtw #1] + WORD $0x79000dcd // strh w13, [x14, #6] + WORD $0x790009d0 // strh w16, [x14, #4] + WORD $0x7862782d // ldrh w13, [x1, x2, lsl #1] + WORD $0x790005cd // strh w13, [x14, #2] + WORD $0xaa0f03ed // mov x13, x15 + WORD $0x53047daf // lsr w15, w13, #4 + WORD $0x7109c5ff // cmp w15, #625 + WORD $0x54fff303 // b.lo LBB0_66 $-416(%rip) +LBB0_74: + WORD $0x529c1ff0 // mov w16, #57599 + WORD $0x72a0beb0 // movk w16, #1525, lsl #16 + WORD $0x5282eb31 // mov w17, #5977 + WORD $0x72ba36f1 // movk w17, #53687, lsl #16 + WORD $0x1284e1e1 // mov w1, #-10000 + WORD $0x5290a3e2 // mov w2, #34079 + WORD $0x72aa3d62 // movk w2, #20971, lsl #16 + WORD $0x52800c83 // mov w3, #100 +Lloh8: + WORD $0x10004924 // adr x4, _Digits $2340(%rip) +Lloh9: + WORD $0x91000084 // add x4, x4, _Digits@PAGEOFF $0(%rip) +LBB0_75: + WORD $0x9bb17daf // umull x15, w13, w17 + WORD $0xd36dfdef // lsr x15, x15, #45 + WORD $0x1b0135e5 // madd w5, w15, w1, w13 + WORD $0x9ba27ca6 // umull x6, w5, w2 + WORD $0xd365fcc6 // lsr x6, x6, #37 + WORD $0x1b0394c5 // msub w5, w6, w3, w5 + WORD $0x78655885 // ldrh w5, [x4, w5, uxtw #1] + WORD $0x78667886 // ldrh w6, [x4, x6, lsl #1] + WORD $0x781fcdc6 // strh w6, [x14, #-4]! + WORD $0x790005c5 // strh w5, [x14, #2] + WORD $0x6b1001bf // cmp w13, w16 + WORD $0xaa0f03ed // mov x13, x15 + WORD $0x54fffe88 // b.hi LBB0_75 $-48(%rip) +LBB0_76: + WORD $0x93407d4a // sxtw x10, w10 + WORD $0x710191ff // cmp w15, #100 + WORD $0x540001a3 // b.lo LBB0_78 $52(%rip) + WORD $0x53023ded // ubfx w13, w15, #2, #14 + WORD $0x52828f70 // mov w16, #5243 + WORD $0x1b107dad // mul w13, w13, w16 + WORD $0x53117dad // lsr w13, w13, #17 + WORD $0x52800c90 // mov w16, #100 + WORD $0x1b10bdaf // msub w15, w13, w16, w15 +Lloh10: + WORD $0x10004630 // adr x16, _Digits $2244(%rip) +Lloh11: + WORD $0x91000210 // add x16, x16, _Digits@PAGEOFF $0(%rip) + WORD $0x92403def // and x15, x15, #0xffff + WORD $0x786f7a0f // ldrh w15, [x16, x15, lsl #1] + WORD $0x781fedcf // strh w15, [x14, #-2]! + WORD $0xaa0d03ef // mov x15, x13 +LBB0_78: + WORD $0x8b0a010d // add x13, x8, x10 + WORD $0x710029ff // cmp w15, #10 + WORD $0x54000163 // b.lo LBB0_81 $44(%rip) +Lloh12: + WORD $0x10004508 // adr x8, _Digits $2208(%rip) +Lloh13: + WORD $0x91000108 // add x8, x8, _Digits@PAGEOFF $0(%rip) + WORD $0x786f5908 // ldrh w8, [x8, w15, uxtw #1] + WORD $0x781fe1c8 // sturh w8, [x14, #-2] + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x5400012b // b.lt LBB0_82 $36(%rip) +LBB0_80: + WORD $0x4b0001a0 // sub w0, w13, w0 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_81: + WORD $0x1100c1ee // add w14, w15, #48 + WORD $0x3900010e // strb w14, [x8] + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x54ffff2a // b.ge LBB0_80 $-28(%rip) +LBB0_82: + WORD $0x8b000128 // add x8, x9, x0 + WORD $0x8b0c010e // add x14, x8, x12 + WORD $0x910005cf // add x15, x14, #1 + WORD $0x8b0a0108 // add x8, x8, x10 + WORD $0xeb0801ff // cmp x15, x8 + WORD $0x9a8e9508 // csinc x8, x8, x14, ls + WORD $0xcb0e010e // sub x14, x8, x14 + WORD $0xf10021df // cmp x14, #8 + WORD $0x54002f63 // b.lo LBB0_146 $1516(%rip) + WORD $0xf10081df // cmp x14, #32 + WORD $0x54000fa2 // b.hs LBB0_104 $500(%rip) + WORD $0xd2800008 // mov x8, #0 + WORD $0x14000089 // b LBB0_108 $548(%rip) +LBB0_85: + WORD $0x5280010f // mov w15, #8 + WORD $0xd10021ce // sub x14, x14, #8 + WORD $0x53047e0d // lsr w13, w16, #4 + WORD $0x7109c5bf // cmp w13, #625 + WORD $0x54ffe883 // b.lo LBB0_62 $-752(%rip) +LBB0_86: + WORD $0x529c1ff1 // mov w17, #57599 + WORD $0x72a0beb1 // movk w17, #1525, lsl #16 + WORD $0x5282eb21 // mov w1, #5977 + WORD $0x72ba36e1 // movk w1, #53687, lsl #16 + WORD $0x1284e1e2 // mov w2, #-10000 + WORD $0x5290a3e3 // mov w3, #34079 + WORD $0x72aa3d63 // movk w3, #20971, lsl #16 + WORD $0x52800c84 // mov w4, #100 +Lloh14: + WORD $0x10004005 // adr x5, _Digits $2048(%rip) +Lloh15: + WORD $0x910000a5 // add x5, x5, _Digits@PAGEOFF $0(%rip) +LBB0_87: + WORD $0x9ba17e0d // umull x13, w16, w1 + WORD $0xd36dfdad // lsr x13, x13, #45 + WORD $0x1b0241a6 // madd w6, w13, w2, w16 + WORD $0x9ba37cc7 // umull x7, w6, w3 + WORD $0xd365fce7 // lsr x7, x7, #37 + WORD $0x1b0498e6 // msub w6, w7, w4, w6 + WORD $0x786658a6 // ldrh w6, [x5, w6, uxtw #1] + WORD $0x786778a7 // ldrh w7, [x5, x7, lsl #1] + WORD $0x781fcdc7 // strh w7, [x14, #-4]! + WORD $0x790005c6 // strh w6, [x14, #2] + WORD $0x6b11021f // cmp w16, w17 + WORD $0xaa0d03f0 // mov x16, x13 + WORD $0x54fffe88 // b.hi LBB0_87 $-48(%rip) +LBB0_88: + WORD $0x710191bf // cmp w13, #100 + WORD $0x540001a3 // b.lo LBB0_90 $52(%rip) + WORD $0x53023db0 // ubfx w16, w13, #2, #14 + WORD $0x52828f71 // mov w17, #5243 + WORD $0x1b117e10 // mul w16, w16, w17 + WORD $0x53117e10 // lsr w16, w16, #17 + WORD $0x52800c91 // mov w17, #100 + WORD $0x1b11b60d // msub w13, w16, w17, w13 +Lloh16: + WORD $0x10003d31 // adr x17, _Digits $1956(%rip) +Lloh17: + WORD $0x91000231 // add x17, x17, _Digits@PAGEOFF $0(%rip) + WORD $0x92403dad // and x13, x13, #0xffff + WORD $0x786d7a2d // ldrh w13, [x17, x13, lsl #1] + WORD $0x781fedcd // strh w13, [x14, #-2]! + WORD $0xaa1003ed // mov x13, x16 +LBB0_90: + WORD $0x710029bf // cmp w13, #10 + WORD $0x540000c3 // b.lo LBB0_92 $24(%rip) +Lloh18: + WORD $0x10003c30 // adr x16, _Digits $1924(%rip) +Lloh19: + WORD $0x91000210 // add x16, x16, _Digits@PAGEOFF $0(%rip) + WORD $0x786d5a0d // ldrh w13, [x16, w13, uxtw #1] + WORD $0x781fe1cd // sturh w13, [x14, #-2] + WORD $0x14000003 // b LBB0_93 $12(%rip) +LBB0_92: + WORD $0x1100c1ad // add w13, w13, #48 + WORD $0x3900016d // strb w13, [x11] +LBB0_93: + WORD $0xcb0f0129 // sub x9, x9, x15 + WORD $0x8b090009 // add x9, x0, x9 + WORD $0x5280002d // mov w13, #1 + WORD $0xcb0f01ad // sub x13, x13, x15 +LBB0_94: + WORD $0x386c692e // ldrb w14, [x9, x12] + WORD $0xd1000529 // sub x9, x9, #1 + WORD $0xd10005ad // sub x13, x13, #1 + WORD $0x7100c1df // cmp w14, #48 + WORD $0x54ffff80 // b.eq LBB0_94 $-16(%rip) + WORD $0x3940050e // ldrb w14, [x8, #1] + WORD $0x3900010e // strb w14, [x8] + WORD $0x8b0d018d // add x13, x12, x13 + WORD $0x8b0c0128 // add x8, x9, x12 + WORD $0xf10009bf // cmp x13, #2 + WORD $0x540003ab // b.lt LBB0_99 $116(%rip) + WORD $0x528005c9 // mov w9, #46 + WORD $0x39000169 // strb w9, [x11] + WORD $0x52800ca9 // mov w9, #101 + WORD $0x38002d09 // strb w9, [x8, #2]! + WORD $0x7100015f // cmp w10, #0 + WORD $0x5400036d // b.le LBB0_100 $108(%rip) +LBB0_97: + WORD $0x51000549 // sub w9, w10, #1 + WORD $0x5280056a // mov w10, #43 + WORD $0x3900050a // strb w10, [x8, #1] + WORD $0x7101913f // cmp w9, #100 + WORD $0x54000383 // b.lo LBB0_101 $112(%rip) +LBB0_98: + WORD $0x529999aa // mov w10, #52429 + WORD $0x72b9998a // movk w10, #52428, lsl #16 + WORD $0x9baa7d2a // umull x10, w9, w10 + WORD $0xd363fd4a // lsr x10, x10, #35 + WORD $0x5280014b // mov w11, #10 + WORD $0x1b0ba549 // msub w9, w10, w11, w9 +Lloh20: + WORD $0x1000374b // adr x11, _Digits $1768(%rip) +Lloh21: + WORD $0x9100016b // add x11, x11, _Digits@PAGEOFF $0(%rip) + WORD $0x786a796a // ldrh w10, [x11, x10, lsl #1] + WORD $0x7900050a // strh w10, [x8, #2] + WORD $0x321c0529 // orr w9, w9, #0x30 + WORD $0x39001109 // strb w9, [x8, #4] + WORD $0x9100150d // add x13, x8, #5 + WORD $0x4b0001a0 // sub w0, w13, w0 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_99: + WORD $0x52800ca9 // mov w9, #101 + WORD $0x38001d09 // strb w9, [x8, #1]! + WORD $0x7100015f // cmp w10, #0 + WORD $0x54fffcec // b.gt LBB0_97 $-100(%rip) +LBB0_100: + WORD $0x528005a9 // mov w9, #45 + WORD $0x39000509 // strb w9, [x8, #1] + WORD $0x52800029 // mov w9, #1 + WORD $0x4b0a0129 // sub w9, w9, w10 + WORD $0x7101913f // cmp w9, #100 + WORD $0x54fffcc2 // b.hs LBB0_98 $-104(%rip) +LBB0_101: + WORD $0x7100293f // cmp w9, #10 + WORD $0x54000143 // b.lo LBB0_103 $40(%rip) +Lloh22: + WORD $0x1000346a // adr x10, _Digits $1676(%rip) +Lloh23: + WORD $0x9100014a // add x10, x10, _Digits@PAGEOFF $0(%rip) + WORD $0x78695949 // ldrh w9, [x10, w9, uxtw #1] + WORD $0x79000509 // strh w9, [x8, #2] + WORD $0x9100110d // add x13, x8, #4 + WORD $0x4b0001a0 // sub w0, w13, w0 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_103: + WORD $0x1100c129 // add w9, w9, #48 + WORD $0x91000d0d // add x13, x8, #3 + WORD $0x39000909 // strb w9, [x8, #2] + WORD $0x4b0001a0 // sub w0, w13, w0 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_104: + WORD $0x927be9c8 // and x8, x14, #0xffffffffffffffe0 + WORD $0x8b0c012f // add x15, x9, x12 + WORD $0x8b0001ef // add x15, x15, x0 + WORD $0x910041ef // add x15, x15, #16 + WORD $0x4f01e600 // movi.16b v0, #48 + WORD $0xaa0803f0 // mov x16, x8 +LBB0_105: + WORD $0xad3f81e0 // stp q0, q0, [x15, #-16] + WORD $0x910081ef // add x15, x15, #32 + WORD $0xf1008210 // subs x16, x16, #32 + WORD $0x54ffffa1 // b.ne LBB0_105 $-12(%rip) + WORD $0xeb0801df // cmp x14, x8 + WORD $0x54ffecc0 // b.eq LBB0_80 $-616(%rip) + WORD $0xf27d05df // tst x14, #0x18 + WORD $0x54001dc0 // b.eq LBB0_145 $952(%rip) +LBB0_108: + WORD $0x8b00012e // add x14, x9, x0 + WORD $0x8b0c01cf // add x15, x14, x12 + WORD $0x910005f0 // add x16, x15, #1 + WORD $0x8b0a01ca // add x10, x14, x10 + WORD $0xeb0a021f // cmp x16, x10 + WORD $0x9a8f954a // csinc x10, x10, x15, ls + WORD $0xcb0f014a // sub x10, x10, x15 + WORD $0x927df14e // and x14, x10, #0xfffffffffffffff8 + WORD $0x8b0e016b // add x11, x11, x14 + WORD $0x8b090109 // add x9, x8, x9 + WORD $0x8b0c0129 // add x9, x9, x12 + WORD $0x8b090009 // add x9, x0, x9 + WORD $0xcb0e0108 // sub x8, x8, x14 + WORD $0x0f01e600 // movi.8b v0, #48 +LBB0_109: + WORD $0xfc008520 // str d0, [x9], #8 + WORD $0xb1002108 // adds x8, x8, #8 + WORD $0x54ffffc1 // b.ne LBB0_109 $-8(%rip) + WORD $0xeb0e015f // cmp x10, x14 + WORD $0x54ffea20 // b.eq LBB0_80 $-700(%rip) + WORD $0x140000db // b LBB0_146 $876(%rip) +LBB0_111: + WORD $0x910005cf // add x15, x14, #1 + WORD $0x927b6dee // and x14, x15, #0x1ffffffe0 + WORD $0x8b0e0108 // add x8, x8, x14 + WORD $0x8b000129 // add x9, x9, x0 + WORD $0x91004929 // add x9, x9, #18 + WORD $0x4f01e600 // movi.16b v0, #48 + WORD $0xaa0e03f0 // mov x16, x14 +LBB0_112: + WORD $0xad3f8120 // stp q0, q0, [x9, #-16] + WORD $0x91008129 // add x9, x9, #32 + WORD $0xf1008210 // subs x16, x16, #32 + WORD $0x54ffffa1 // b.ne LBB0_112 $-12(%rip) + WORD $0xeb0e01ff // cmp x15, x14 + WORD $0x540000e0 // b.eq LBB0_116 $28(%rip) +LBB0_114: + WORD $0x0b0a01c9 // add w9, w14, w10 + WORD $0x4b0903e9 // neg w9, w9 + WORD $0x5280060e // mov w14, #48 +LBB0_115: + WORD $0x3800150e // strb w14, [x8], #1 + WORD $0x71000529 // subs w9, w9, #1 + WORD $0x54ffffc1 // b.ne LBB0_115 $-8(%rip) +LBB0_116: + WORD $0x2a0c03e9 // mov w9, w12 + WORD $0x8b09010f // add x15, x8, x9 + WORD $0xd360fdae // lsr x14, x13, #32 + WORD $0xb500010e // cbnz x14, LBB0_119 $32(%rip) + WORD $0xaa0d03f0 // mov x16, x13 + WORD $0xaa0f03ed // mov x13, x15 + WORD $0x53047e11 // lsr w17, w16, #4 + WORD $0x7109c63f // cmp w17, #625 + WORD $0x540006e2 // b.hs LBB0_122 $220(%rip) +LBB0_118: + WORD $0xaa1003f1 // mov x17, x16 + WORD $0x1400004c // b LBB0_124 $304(%rip) +LBB0_119: + WORD $0xd299dfae // mov x14, #52989 + WORD $0xf2b08c2e // movk x14, #33889, lsl #16 + WORD $0xf2cee22e // movk x14, #30481, lsl #32 + WORD $0xf2f5798e // movk x14, #43980, lsl #48 + WORD $0x9bce7dae // umulh x14, x13, x14 + WORD $0xd35afdd0 // lsr x16, x14, #26 + WORD $0x5283e00e // mov w14, #7936 + WORD $0x72bf414e // movk w14, #64010, lsl #16 + WORD $0x1b0e360d // madd w13, w16, w14, w13 + WORD $0x340004cd // cbz w13, LBB0_121 $152(%rip) + WORD $0xd280000e // mov x14, #0 + WORD $0x5282eb31 // mov w17, #5977 + WORD $0x72ba36f1 // movk w17, #53687, lsl #16 + WORD $0x9bb17da1 // umull x1, w13, w17 + WORD $0xd36dfc21 // lsr x1, x1, #45 + WORD $0x5284e202 // mov w2, #10000 + WORD $0x1b02b42d // msub w13, w1, w2, w13 + WORD $0x9b117c31 // mul x17, x1, x17 + WORD $0xd36dfe31 // lsr x17, x17, #45 + WORD $0x1b028631 // msub w17, w17, w2, w1 + WORD $0x53023da1 // ubfx w1, w13, #2, #14 + WORD $0x52828f62 // mov w2, #5243 + WORD $0x1b027c21 // mul w1, w1, w2 + WORD $0x53117c21 // lsr w1, w1, #17 + WORD $0x53023e23 // ubfx w3, w17, #2, #14 + WORD $0x1b027c62 // mul w2, w3, w2 + WORD $0x52800c83 // mov w3, #100 + WORD $0x1b03b42d // msub w13, w1, w3, w13 + WORD $0x92403dad // and x13, x13, #0xffff + WORD $0x53117c42 // lsr w2, w2, #17 + WORD $0x1b03c451 // msub w17, w2, w3, w17 + WORD $0x92403e31 // and x17, x17, #0xffff +Lloh24: + WORD $0x10002663 // adr x3, _Digits $1228(%rip) +Lloh25: + WORD $0x91000063 // add x3, x3, _Digits@PAGEOFF $0(%rip) + WORD $0x786d786d // ldrh w13, [x3, x13, lsl #1] + WORD $0x781fe1ed // sturh w13, [x15, #-2] + WORD $0x7861586d // ldrh w13, [x3, w1, uxtw #1] + WORD $0x781fc1ed // sturh w13, [x15, #-4] + WORD $0x7871786d // ldrh w13, [x3, x17, lsl #1] + WORD $0x781fa1ed // sturh w13, [x15, #-6] + WORD $0x7862586d // ldrh w13, [x3, w2, uxtw #1] + WORD $0x781f81ed // sturh w13, [x15, #-8] + WORD $0xd10021ed // sub x13, x15, #8 + WORD $0x53047e11 // lsr w17, w16, #4 + WORD $0x7109c63f // cmp w17, #625 + WORD $0x54fffa23 // b.lo LBB0_118 $-188(%rip) + WORD $0x14000006 // b LBB0_122 $24(%rip) +LBB0_121: + WORD $0x5280010e // mov w14, #8 + WORD $0xd10021ed // sub x13, x15, #8 + WORD $0x53047e11 // lsr w17, w16, #4 + WORD $0x7109c63f // cmp w17, #625 + WORD $0x54fff963 // b.lo LBB0_118 $-212(%rip) +LBB0_122: + WORD $0x529c1fe1 // mov w1, #57599 + WORD $0x72a0bea1 // movk w1, #1525, lsl #16 + WORD $0x5282eb22 // mov w2, #5977 + WORD $0x72ba36e2 // movk w2, #53687, lsl #16 + WORD $0x1284e1e3 // mov w3, #-10000 + WORD $0x5290a3e4 // mov w4, #34079 + WORD $0x72aa3d64 // movk w4, #20971, lsl #16 + WORD $0x52800c85 // mov w5, #100 +Lloh26: + WORD $0x100022e6 // adr x6, _Digits $1116(%rip) +Lloh27: + WORD $0x910000c6 // add x6, x6, _Digits@PAGEOFF $0(%rip) +LBB0_123: + WORD $0x9ba27e11 // umull x17, w16, w2 + WORD $0xd36dfe31 // lsr x17, x17, #45 + WORD $0x1b034227 // madd w7, w17, w3, w16 + WORD $0x9ba47cf3 // umull x19, w7, w4 + WORD $0xd365fe73 // lsr x19, x19, #37 + WORD $0x1b059e67 // msub w7, w19, w5, w7 + WORD $0x786758c7 // ldrh w7, [x6, w7, uxtw #1] + WORD $0x787378d3 // ldrh w19, [x6, x19, lsl #1] + WORD $0x781fcdb3 // strh w19, [x13, #-4]! + WORD $0x790005a7 // strh w7, [x13, #2] + WORD $0x6b01021f // cmp w16, w1 + WORD $0xaa1103f0 // mov x16, x17 + WORD $0x54fffe88 // b.hi LBB0_123 $-48(%rip) +LBB0_124: + WORD $0x7101923f // cmp w17, #100 + WORD $0x540001a3 // b.lo LBB0_126 $52(%rip) + WORD $0x53023e30 // ubfx w16, w17, #2, #14 + WORD $0x52828f61 // mov w1, #5243 + WORD $0x1b017e10 // mul w16, w16, w1 + WORD $0x53117e10 // lsr w16, w16, #17 + WORD $0x52800c81 // mov w1, #100 + WORD $0x1b01c611 // msub w17, w16, w1, w17 +Lloh28: + WORD $0x10002001 // adr x1, _Digits $1024(%rip) +Lloh29: + WORD $0x91000021 // add x1, x1, _Digits@PAGEOFF $0(%rip) + WORD $0x92403e31 // and x17, x17, #0xffff + WORD $0x78717831 // ldrh w17, [x1, x17, lsl #1] + WORD $0x781fedb1 // strh w17, [x13, #-2]! + WORD $0xaa1003f1 // mov x17, x16 +LBB0_126: + WORD $0x71002a3f // cmp w17, #10 + WORD $0x540000c3 // b.lo LBB0_128 $24(%rip) +Lloh30: + WORD $0x10001f10 // adr x16, _Digits $992(%rip) +Lloh31: + WORD $0x91000210 // add x16, x16, _Digits@PAGEOFF $0(%rip) + WORD $0x78715a10 // ldrh w16, [x16, w17, uxtw #1] + WORD $0x781fe1b0 // sturh w16, [x13, #-2] + WORD $0x14000003 // b LBB0_129 $12(%rip) +LBB0_128: + WORD $0x1100c22d // add w13, w17, #48 + WORD $0x3900010d // strb w13, [x8] +LBB0_129: + WORD $0xd2800010 // mov x16, #0 + WORD $0xcb0e01ef // sub x15, x15, x14 + WORD $0x0b0e016d // add w13, w11, w14 + WORD $0x4b0d03e1 // neg w1, w13 + WORD $0x510005a2 // sub w2, w13, #1 + WORD $0x510009b1 // sub w17, w13, #2 + WORD $0xaa0f03ed // mov x13, x15 +LBB0_130: + WORD $0xd10005ad // sub x13, x13, #1 + WORD $0x8b1001e3 // add x3, x15, x16 + WORD $0x385ff063 // ldurb w3, [x3, #-1] + WORD $0xd1000610 // sub x16, x16, #1 + WORD $0x11000631 // add w17, w17, #1 + WORD $0x7100c07f // cmp w3, #48 + WORD $0x54ffff40 // b.eq LBB0_130 $-24(%rip) + WORD $0x8b1001ed // add x13, x15, x16 + WORD $0x910005ad // add x13, x13, #1 + WORD $0x7100055f // cmp w10, #1 + WORD $0x54ffd7cb // b.lt LBB0_80 $-1288(%rip) + WORD $0x4b0e018c // sub w12, w12, w14 + WORD $0x0b10018c // add w12, w12, w16 + WORD $0x1100058c // add w12, w12, #1 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x5400030a // b.ge LBB0_137 $96(%rip) + WORD $0x0b100029 // add w9, w1, w16 + WORD $0x11000529 // add w9, w9, #1 + WORD $0x7100053f // cmp w9, #1 + WORD $0x5400018b // b.lt LBB0_136 $48(%rip) + WORD $0xd2800009 // mov x9, #0 + WORD $0x8b21c20b // add x11, x16, w1, sxtw + WORD $0x9100056b // add x11, x11, #1 + WORD $0xcb2b412b // sub x11, x9, w11, uxtw + WORD $0x8b1001ec // add x12, x15, x16 +LBB0_135: + WORD $0x8b09018d // add x13, x12, x9 + WORD $0x3869698e // ldrb w14, [x12, x9] + WORD $0x390005ae // strb w14, [x13, #1] + WORD $0xd1000529 // sub x9, x9, #1 + WORD $0xeb09017f // cmp x11, x9 + WORD $0x54ffff61 // b.ne LBB0_135 $-20(%rip) +LBB0_136: + WORD $0x528005c9 // mov w9, #46 + WORD $0x382ac909 // strb w9, [x8, w10, sxtw] + WORD $0x8b1001e8 // add x8, x15, x16 + WORD $0x9100090d // add x13, x8, #2 + WORD $0x4b0001a0 // sub w0, w13, w0 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_137: + WORD $0xcb10004a // sub x10, x2, x16 + WORD $0x7100055f // cmp w10, #1 + WORD $0x54ffd3eb // b.lt LBB0_80 $-1412(%rip) + WORD $0x0b0e016c // add w12, w11, w14 + WORD $0x5100098c // sub w12, w12, #2 + WORD $0xcb100181 // sub x1, x12, x16 + WORD $0x71007c3f // cmp w1, #31 + WORD $0x54000062 // b.hs LBB0_140 $12(%rip) + WORD $0x5280000b // mov w11, #0 + WORD $0x1400001c // b LBB0_143 $112(%rip) +LBB0_140: + WORD $0xd280000c // mov x12, #0 + WORD $0x0b0e016b // add w11, w11, w14 + WORD $0x5100096b // sub w11, w11, #2 + WORD $0xcb100162 // sub x2, x11, x16 + WORD $0x92407c2b // and x11, x1, #0xffffffff + WORD $0x91000561 // add x1, x11, #1 + WORD $0x927b6c2b // and x11, x1, #0x1ffffffe0 + WORD $0xcb0e0129 // sub x9, x9, x14 + WORD $0x8b080128 // add x8, x9, x8 + WORD $0x91000629 // add x9, x17, #1 + WORD $0x927b6d29 // and x9, x9, #0x1ffffffe0 + WORD $0x8b090108 // add x8, x8, x9 + WORD $0x8b100108 // add x8, x8, x16 + WORD $0x9100050d // add x13, x8, #1 + WORD $0x92407c48 // and x8, x2, #0xffffffff + WORD $0x91000508 // add x8, x8, #1 + WORD $0x927b6d08 // and x8, x8, #0x1ffffffe0 + WORD $0x4f01e600 // movi.16b v0, #48 +LBB0_141: + WORD $0x8b0c01e9 // add x9, x15, x12 + WORD $0x8b100129 // add x9, x9, x16 + WORD $0x3c801120 // stur q0, [x9, #1] + WORD $0x3c811120 // stur q0, [x9, #17] + WORD $0x9100818c // add x12, x12, #32 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x54ffff41 // b.ne LBB0_141 $-24(%rip) + WORD $0xeb0b003f // cmp x1, x11 + WORD $0x54ffcfa0 // b.eq LBB0_80 $-1548(%rip) +LBB0_143: + WORD $0x52800608 // mov w8, #48 +LBB0_144: + WORD $0x380015a8 // strb w8, [x13], #1 + WORD $0x1100056b // add w11, w11, #1 + WORD $0x6b0a017f // cmp w11, w10 + WORD $0x54ffffab // b.lt LBB0_144 $-12(%rip) + WORD $0x17fffe77 // b LBB0_80 $-1572(%rip) +LBB0_145: + WORD $0x8b08016b // add x11, x11, x8 +LBB0_146: + WORD $0x52800608 // mov w8, #48 +LBB0_147: + WORD $0x38001568 // strb w8, [x11], #1 + WORD $0xeb0d017f // cmp x11, x13 + WORD $0x54ffffc3 // b.lo LBB0_147 $-8(%rip) + WORD $0x17fffe71 // b LBB0_80 $-1596(%rip) +LBB0_148: + WORD $0xd2adf82b // mov x11, #1874919424 + WORD $0xf2d0de4b // movk x11, #34546, lsl #32 + WORD $0xf2e0046b // movk x11, #35, lsl #48 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x5280020b // mov w11, #16 + WORD $0x9a8b356b // cinc x11, x11, hs +LBB0_149: + WORD $0x8b0b010b // add x11, x8, x11 +LBB0_150: + WORD $0xd299dfac // mov x12, #52989 + WORD $0xf2b08c2c // movk x12, #33889, lsl #16 + WORD $0xf2cee22c // movk x12, #30481, lsl #32 + WORD $0xf2f5798c // movk x12, #43980, lsl #48 + WORD $0x9bcc7d4c // umulh x12, x10, x12 + WORD $0xd35afd8d // lsr x13, x12, #26 + WORD $0x5283e00c // mov w12, #7936 + WORD $0x72bf414c // movk w12, #64010, lsl #16 + WORD $0x1b0c29aa // madd w10, w13, w12, w10 + WORD $0x5282eb2c // mov w12, #5977 + WORD $0x72ba36ec // movk w12, #53687, lsl #16 + WORD $0x9bac7d4e // umull x14, w10, w12 + WORD $0xd36dfdce // lsr x14, x14, #45 + WORD $0x5284e20f // mov w15, #10000 + WORD $0x1b0fa9ca // msub w10, w14, w15, w10 + WORD $0x9b0c7dcc // mul x12, x14, x12 + WORD $0xd36dfd8c // lsr x12, x12, #45 + WORD $0x1b0fb98c // msub w12, w12, w15, w14 + WORD $0x53023d4e // ubfx w14, w10, #2, #14 + WORD $0x52828f6f // mov w15, #5243 + WORD $0x1b0f7dce // mul w14, w14, w15 + WORD $0x53117dce // lsr w14, w14, #17 + WORD $0x52800c90 // mov w16, #100 + WORD $0x1b10a9ca // msub w10, w14, w16, w10 + WORD $0x92403d4a // and x10, x10, #0xffff + WORD $0x53023d91 // ubfx w17, w12, #2, #14 + WORD $0x1b0f7e2f // mul w15, w17, w15 + WORD $0x53117def // lsr w15, w15, #17 + WORD $0x1b10b1ec // msub w12, w15, w16, w12 + WORD $0x786a792a // ldrh w10, [x9, x10, lsl #1] + WORD $0x786f592f // ldrh w15, [x9, w15, uxtw #1] + WORD $0x92403d90 // and x16, x12, #0xffff + WORD $0xaa0b03ec // mov x12, x11 + WORD $0x781f8d8f // strh w15, [x12, #-8]! + WORD $0x786e592e // ldrh w14, [x9, w14, uxtw #1] + WORD $0x79000d8a // strh w10, [x12, #6] + WORD $0x7900098e // strh w14, [x12, #4] + WORD $0x7870792a // ldrh w10, [x9, x16, lsl #1] + WORD $0x7900058a // strh w10, [x12, #2] + WORD $0xaa0d03ea // mov x10, x13 + WORD $0xd3447d4d // ubfx x13, x10, #4, #28 + WORD $0x7109c5bf // cmp w13, #625 + WORD $0x54000ba3 // b.lo LBB0_169 $372(%rip) +LBB0_151: + WORD $0x529c1fee // mov w14, #57599 + WORD $0x72a0beae // movk w14, #1525, lsl #16 + WORD $0x5282eb2f // mov w15, #5977 + WORD $0x72ba36ef // movk w15, #53687, lsl #16 + WORD $0x1284e1f0 // mov w16, #-10000 + WORD $0x5290a3f1 // mov w17, #34079 + WORD $0x72aa3d71 // movk w17, #20971, lsl #16 + WORD $0x52800c81 // mov w1, #100 +LBB0_152: + WORD $0x9baf7d4d // umull x13, w10, w15 + WORD $0xd36dfdad // lsr x13, x13, #45 + WORD $0x1b1029a2 // madd w2, w13, w16, w10 + WORD $0x9bb17c43 // umull x3, w2, w17 + WORD $0xd365fc63 // lsr x3, x3, #37 + WORD $0x1b018862 // msub w2, w3, w1, w2 + WORD $0x78625922 // ldrh w2, [x9, w2, uxtw #1] + WORD $0x78637923 // ldrh w3, [x9, x3, lsl #1] + WORD $0x781fcd83 // strh w3, [x12, #-4]! + WORD $0x79000582 // strh w2, [x12, #2] + WORD $0x6b0e015f // cmp w10, w14 + WORD $0xaa0d03ea // mov x10, x13 + WORD $0x54fffe88 // b.hi LBB0_152 $-48(%rip) + WORD $0x710191bf // cmp w13, #100 + WORD $0x54000163 // b.lo LBB0_155 $44(%rip) +LBB0_154: + WORD $0x53023daa // ubfx w10, w13, #2, #14 + WORD $0x52828f6e // mov w14, #5243 + WORD $0x1b0e7d4a // mul w10, w10, w14 + WORD $0x53117d4a // lsr w10, w10, #17 + WORD $0x52800c8e // mov w14, #100 + WORD $0x1b0eb54d // msub w13, w10, w14, w13 + WORD $0x92403dad // and x13, x13, #0xffff + WORD $0x786d792d // ldrh w13, [x9, x13, lsl #1] + WORD $0x781fed8d // strh w13, [x12, #-2]! + WORD $0xaa0a03ed // mov x13, x10 +LBB0_155: + WORD $0x710029bf // cmp w13, #10 + WORD $0x540000e3 // b.lo LBB0_157 $28(%rip) + WORD $0x786d5928 // ldrh w8, [x9, w13, uxtw #1] + WORD $0x781fe188 // sturh w8, [x12, #-2] + WORD $0x4b000160 // sub w0, w11, w0 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_157: + WORD $0x1100c1a9 // add w9, w13, #48 + WORD $0x39000109 // strb w9, [x8] + WORD $0x4b000160 // sub w0, w11, w0 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_158: + WORD $0x5288480b // mov w11, #16960 + WORD $0x72a001eb // movk w11, #15, lsl #16 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x54000122 // b.hs LBB0_161 $36(%rip) + WORD $0x528000cb // mov w11, #6 + WORD $0x8b0b010b // add x11, x8, x11 + WORD $0x14000023 // b LBB0_168 $140(%rip) +LBB0_160: + WORD $0x5299400a // mov w10, #51712 + WORD $0x72a7734a // movk w10, #15258, lsl #16 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x5280012a // mov w10, #9 + WORD $0x17fffd27 // b LBB0_44 $-2916(%rip) +LBB0_161: + WORD $0x5292d00b // mov w11, #38528 + WORD $0x72a0130b // movk w11, #152, lsl #16 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x54000102 // b.hs LBB0_164 $32(%rip) + WORD $0x528000eb // mov w11, #7 + WORD $0x8b0b010b // add x11, x8, x11 + WORD $0x14000017 // b LBB0_168 $92(%rip) +LBB0_163: + WORD $0x52800000 // mov w0, #0 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_164: + WORD $0x529c200b // mov w11, #57600 + WORD $0x72a0beab // movk w11, #1525, lsl #16 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x540000e2 // b.hs LBB0_167 $28(%rip) + WORD $0x5280010b // mov w11, #8 + WORD $0x8b0b010b // add x11, x8, x11 + WORD $0x1400000c // b LBB0_168 $48(%rip) +LBB0_166: + WORD $0x1280862c // mov w12, #-1074 + WORD $0xaa0d03ea // mov x10, x13 + WORD $0x17fffc39 // b LBB0_5 $-3868(%rip) +LBB0_167: + WORD $0x5299400b // mov w11, #51712 + WORD $0x72a7734b // movk w11, #15258, lsl #16 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x5280012b // mov w11, #9 + WORD $0x9a8b356b // cinc x11, x11, hs + WORD $0x8b0b010b // add x11, x8, x11 + WORD $0xd360fd4c // lsr x12, x10, #32 + WORD $0xb5ffefcc // cbnz x12, LBB0_150 $-520(%rip) +LBB0_168: + WORD $0xaa0b03ec // mov x12, x11 + WORD $0xd3447d4d // ubfx x13, x10, #4, #28 + WORD $0x7109c5bf // cmp w13, #625 + WORD $0x54fff4a2 // b.hs LBB0_151 $-364(%rip) +LBB0_169: + WORD $0xaa0a03ed // mov x13, x10 + WORD $0x710191bf // cmp w13, #100 + WORD $0x54fff722 // b.hs LBB0_154 $-284(%rip) + WORD $0x17ffffc2 // b LBB0_155 $-248(%rip) +_Digits: + WORD $0x31303030 // .ascii 4, '0001020304050607' + WORD $0x33303230 // .ascii 4, '0203040506070809' + WORD $0x35303430 // .ascii 4, '0405060708091011' + WORD $0x37303630 // .ascii 4, '0607080910111213' + WORD $0x39303830 // .ascii 4, '0809101112131415' + WORD $0x31313031 // .ascii 4, '1011121314151617' + WORD $0x33313231 // .ascii 4, '1213141516171819' + WORD $0x35313431 // .ascii 4, '1415161718192021' + WORD $0x37313631 // .ascii 4, '1617181920212223' + WORD $0x39313831 // .ascii 4, '1819202122232425' + WORD $0x31323032 // .ascii 4, '2021222324252627' + WORD $0x33323232 // .ascii 4, '2223242526272829' + WORD $0x35323432 // .ascii 4, '2425262728293031' + WORD $0x37323632 // .ascii 4, '2627282930313233' + WORD $0x39323832 // .ascii 4, '2829303132333435' + WORD $0x31333033 // .ascii 4, '3031323334353637' + WORD $0x33333233 // .ascii 4, '3233343536373839' + WORD $0x35333433 // .ascii 4, '3435363738394041' + WORD $0x37333633 // .ascii 4, '3637383940414243' + WORD $0x39333833 // .ascii 4, '3839404142434445' + WORD $0x31343034 // .ascii 4, '4041424344454647' + WORD $0x33343234 // .ascii 4, '4243444546474849' + WORD $0x35343434 // .ascii 4, '4445464748495051' + WORD $0x37343634 // .ascii 4, '4647484950515253' + WORD $0x39343834 // .ascii 4, '4849505152535455' + WORD $0x31353035 // .ascii 4, '5051525354555657' + WORD $0x33353235 // .ascii 4, '5253545556575859' + WORD $0x35353435 // .ascii 4, '5455565758596061' + WORD $0x37353635 // .ascii 4, '5657585960616263' + WORD $0x39353835 // .ascii 4, '5859606162636465' + WORD $0x31363036 // .ascii 4, '6061626364656667' + WORD $0x33363236 // .ascii 4, '6263646566676869' + WORD $0x35363436 // .ascii 4, '6465666768697071' + WORD $0x37363636 // .ascii 4, '6667686970717273' + WORD $0x39363836 // .ascii 4, '6869707172737475' + WORD $0x31373037 // .ascii 4, '7071727374757677' + WORD $0x33373237 // .ascii 4, '7273747576777879' + WORD $0x35373437 // .ascii 4, '7475767778798081' + WORD $0x37373637 // .ascii 4, '7677787980818283' + WORD $0x39373837 // .ascii 4, '7879808182838485' + WORD $0x31383038 // .ascii 4, '8081828384858687' + WORD $0x33383238 // .ascii 4, '8283848586878889' + WORD $0x35383438 // .ascii 4, '8485868788899091' + WORD $0x37383638 // .ascii 4, '8687888990919293' + WORD $0x39383838 // .ascii 4, '8889909192939495' + WORD $0x31393039 // .ascii 4, '9091929394959697' + WORD $0x33393239 // .ascii 4, '9293949596979899' + WORD $0x35393439 // .ascii 4, '949596979899' + WORD $0x37393639 // .ascii 4, '96979899' + WORD $0x39393839 // .ascii 4, '9899' + // .p2align 3, 0x00 +_LB_54bf036b: // _pow10_ceil_sig.g + WORD $0xbebcdc4f; WORD $0xff77b1fc // .quad -38366372719436721 + WORD $0x13bb0f7b; WORD $0x25e8e89c // .quad 2731688931043774331 + WORD $0xf73609b1; WORD $0x9faacf3d // .quad -6941508010590729807 + WORD $0x8c54e9ad; WORD $0x77b19161 // .quad 8624834609543440813 + WORD $0x75038c1d; WORD $0xc795830d // .quad -4065198994811024355 + WORD $0xef6a2418; WORD $0xd59df5b9 // .quad -3054014793352862696 + WORD $0xd2446f25; WORD $0xf97ae3d0 // .quad -469812725086392539 + WORD $0x6b44ad1e; WORD $0x4b057328 // .quad 5405853545163697438 + WORD $0x836ac577; WORD $0x9becce62 // .quad -7211161980820077193 + WORD $0x430aec33; WORD $0x4ee367f9 // .quad 5684501474941004851 + WORD $0x244576d5; WORD $0xc2e801fb // .quad -4402266457597708587 + WORD $0x93cda740; WORD $0x229c41f7 // .quad 2493940825248868160 + WORD $0xed56d48a; WORD $0xf3a20279 // .quad -891147053569747830 + WORD $0x78c11110; WORD $0x6b435275 // .quad 7729112049988473104 + WORD $0x345644d6; WORD $0x9845418c // .quad -7474495936122174250 + WORD $0x6b78aaaa; WORD $0x830a1389 // .quad -9004363024039368022 + WORD $0x416bd60c; WORD $0xbe5691ef // .quad -4731433901725329908 + WORD $0xc656d554; WORD $0x23cc986b // .quad 2579604275232953684 + WORD $0x11c6cb8f; WORD $0xedec366b // .quad -1302606358729274481 + WORD $0xb7ec8aa9; WORD $0x2cbfbe86 // .quad 3224505344041192105 + WORD $0xeb1c3f39; WORD $0x94b3a202 // .quad -7731658001846878407 + WORD $0x32f3d6aa; WORD $0x7bf7d714 // .quad 8932844867666826922 + WORD $0xa5e34f07; WORD $0xb9e08a83 // .quad -5052886483881210105 + WORD $0x3fb0cc54; WORD $0xdaf5ccd9 // .quad -2669001970698630060 + WORD $0x8f5c22c9; WORD $0xe858ad24 // .quad -1704422086424124727 + WORD $0x8f9cff69; WORD $0xd1b3400f // .quad -3336252463373287575 + WORD $0xd99995be; WORD $0x91376c36 // .quad -7982792831656159810 + WORD $0xb9c21fa2; WORD $0x23100809 // .quad 2526528228819083170 + WORD $0x8ffffb2d; WORD $0xb5854744 // .quad -5366805021142811859 + WORD $0x2832a78b; WORD $0xabd40a0c // .quad -6065211750830921845 + WORD $0xb3fff9f9; WORD $0xe2e69915 // .quad -2096820258001126919 + WORD $0x323f516d; WORD $0x16c90c8f // .quad 1641857348316123501 + WORD $0x907ffc3b; WORD $0x8dd01fad // .quad -8228041688891786181 + WORD $0x7f6792e4; WORD $0xae3da7d9 // .quad -5891368184943504668 + WORD $0xf49ffb4a; WORD $0xb1442798 // .quad -5673366092687344822 + WORD $0xdf41779d; WORD $0x99cd11cf // .quad -7364210231179380835 + WORD $0x31c7fa1d; WORD $0xdd95317f // .quad -2480021597431793123 + WORD $0xd711d584; WORD $0x40405643 // .quad 4629795266307937668 + WORD $0x7f1cfc52; WORD $0x8a7d3eef // .quad -8467542526035952558 + WORD $0x666b2573; WORD $0x482835ea // .quad 5199465050656154995 + WORD $0x5ee43b66; WORD $0xad1c8eab // .quad -5972742139117552794 + WORD $0x0005eed0; WORD $0xda324365 // .quad -2724040723534582064 + WORD $0x369d4a40; WORD $0xd863b256 // .quad -2854241655469553088 + WORD $0x40076a83; WORD $0x90bed43e // .quad -8016736922845615485 + WORD $0xe2224e68; WORD $0x873e4f75 // .quad -8701430062309552536 + WORD $0xe804a292; WORD $0x5a7744a6 // .quad 6518754469289960082 + WORD $0x5aaae202; WORD $0xa90de353 // .quad -6265101559459552766 + WORD $0xa205cb37; WORD $0x711515d0 // .quad 8148443086612450103 + WORD $0x31559a83; WORD $0xd3515c28 // .quad -3219690930897053053 + WORD $0xca873e04; WORD $0x0d5a5b44 // .quad 962181821410786820 + WORD $0x1ed58091; WORD $0x8412d999 // .quad -8929835859451740015 + WORD $0xfe9486c3; WORD $0xe858790a // .quad -1704479370831952189 + WORD $0x668ae0b6; WORD $0xa5178fff // .quad -6550608805887287114 + WORD $0xbe39a873; WORD $0x626e974d // .quad 7092772823314835571 + WORD $0x402d98e3; WORD $0xce5d73ff // .quad -3576574988931720989 + WORD $0x2dc81290; WORD $0xfb0a3d21 // .quad -357406007711231344 + WORD $0x881c7f8e; WORD $0x80fa687f // .quad -9152888395723407474 + WORD $0xbc9d0b9a; WORD $0x7ce66634 // .quad 8999993282035256218 + WORD $0x6a239f72; WORD $0xa139029f // .quad -6829424476226871438 + WORD $0xebc44e81; WORD $0x1c1fffc1 // .quad 2026619565689294465 + WORD $0x44ac874e; WORD $0xc9874347 // .quad -3925094576856201394 + WORD $0x66b56221; WORD $0xa327ffb2 // .quad -6690097579743157727 + WORD $0x15d7a922; WORD $0xfbe91419 // .quad -294682202642863838 + WORD $0x0062baa9; WORD $0x4bf1ff9f // .quad 5472436080603216553 + WORD $0xada6c9b5; WORD $0x9d71ac8f // .quad -7101705404292871755 + WORD $0x603db4aa; WORD $0x6f773fc3 // .quad 8031958568804398250 + WORD $0x99107c22; WORD $0xc4ce17b3 // .quad -4265445736938701790 + WORD $0x384d21d4; WORD $0xcb550fb4 // .quad -3795109844276665900 + WORD $0x7f549b2b; WORD $0xf6019da0 // .quad -720121152745989333 + WORD $0x46606a49; WORD $0x7e2a53a1 // .quad 9091170749936331337 + WORD $0x4f94e0fb; WORD $0x99c10284 // .quad -7367604748107325189 + WORD $0xcbfc426e; WORD $0x2eda7444 // .quad 3376138709496513134 + WORD $0x637a1939; WORD $0xc0314325 // .quad -4597819916706768583 + WORD $0xfefb5309; WORD $0xfa911155 // .quad -391512631556746487 + WORD $0xbc589f88; WORD $0xf03d93ee // .quad -1135588877456072824 + WORD $0x7eba27cb; WORD $0x793555ab // .quad 8733981247408842699 + WORD $0x35b763b5; WORD $0x96267c75 // .quad -7627272076051127371 + WORD $0x2f3458df; WORD $0x4bc1558b // .quad 5458738279630526687 + WORD $0x83253ca2; WORD $0xbbb01b92 // .quad -4922404076636521310 + WORD $0xfb016f17; WORD $0x9eb1aaed // .quad -7011635205744005353 + WORD $0x23ee8bcb; WORD $0xea9c2277 // .quad -1541319077368263733 + WORD $0x79c1cadd; WORD $0x465e15a9 // .quad 5070514048102157021 + WORD $0x7675175f; WORD $0x92a1958a // .quad -7880853450996246689 + WORD $0xec191eca; WORD $0x0bfacd89 // .quad 863228270850154186 + WORD $0x14125d36; WORD $0xb749faed // .quad -5239380795317920458 + WORD $0x671f667c; WORD $0xcef980ec // .quad -3532650679864695172 + WORD $0x5916f484; WORD $0xe51c79a8 // .quad -1937539975720012668 + WORD $0x80e7401b; WORD $0x82b7e127 // .quad -9027499368258256869 + WORD $0x37ae58d2; WORD $0x8f31cc09 // .quad -8128491512466089774 + WORD $0xb0908811; WORD $0xd1b2ecb8 // .quad -3336344095947716591 + WORD $0x8599ef07; WORD $0xb2fe3f0b // .quad -5548928372155224313 + WORD $0xdcb4aa16; WORD $0x861fa7e6 // .quad -8782116138362033642 + WORD $0x67006ac9; WORD $0xdfbdcece // .quad -2324474446766642487 + WORD $0x93e1d49b; WORD $0x67a791e0 // .quad 7469098900757009563 + WORD $0x006042bd; WORD $0x8bd6a141 // .quad -8370325556870233411 + WORD $0x5c6d24e1; WORD $0xe0c8bb2c // .quad -2249342214667950879 + WORD $0x4078536d; WORD $0xaecc4991 // .quad -5851220927660403859 + WORD $0x73886e19; WORD $0x58fae9f7 // .quad 6411694268519837209 + WORD $0x90966848; WORD $0xda7f5bf5 // .quad -2702340141148116920 + WORD $0x506a899f; WORD $0xaf39a475 // .quad -5820440219632367201 + WORD $0x7a5e012d; WORD $0x888f9979 // .quad -8606491615858654931 + WORD $0x52429604; WORD $0x6d8406c9 // .quad 7891439908798240260 + WORD $0xd8f58178; WORD $0xaab37fd7 // .quad -6146428501395930760 + WORD $0xa6d33b84; WORD $0xc8e5087b // .quad -3970758169284363388 + WORD $0xcf32e1d6; WORD $0xd5605fcd // .quad -3071349608317525546 + WORD $0x90880a65; WORD $0xfb1e4a9a // .quad -351761693178066331 + WORD $0xa17fcd26; WORD $0x855c3be0 // .quad -8837122532839535322 + WORD $0x9a550680; WORD $0x5cf2eea0 // .quad 6697677969404790400 + WORD $0xc9dfc06f; WORD $0xa6b34ad8 // .quad -6434717147622031249 + WORD $0xc0ea481f; WORD $0xf42faa48 // .quad -851274575098787809 + WORD $0xfc57b08b; WORD $0xd0601d8e // .quad -3431710416100151157 + WORD $0xf124da27; WORD $0xf13b94da // .quad -1064093218873484761 + WORD $0x5db6ce57; WORD $0x823c1279 // .quad -9062348037703676329 + WORD $0xd6b70859; WORD $0x76c53d08 // .quad 8558313775058847833 + WORD $0xb52481ed; WORD $0xa2cb1717 // .quad -6716249028702207507 + WORD $0x0c64ca6f; WORD $0x54768c4b // .quad 6086206200396171887 + WORD $0xa26da268; WORD $0xcb7ddcdd // .quad -3783625267450371480 + WORD $0xcf7dfd0a; WORD $0xa9942f5d // .quad -6227300304786948854 + WORD $0x0b090b02; WORD $0xfe5d5415 // .quad -117845565885576446 + WORD $0x435d7c4d; WORD $0xd3f93b35 // .quad -3172439362556298163 + WORD $0x26e5a6e1; WORD $0x9efa548d // .quad -6991182506319567135 + WORD $0x4a1a6db0; WORD $0xc47bc501 // .quad -4288617610811380304 + WORD $0x709f109a; WORD $0xc6b8e9b0 // .quad -4127292114472071014 + WORD $0x9ca1091c; WORD $0x359ab641 // .quad 3862600023340550428 + WORD $0x8cc6d4c0; WORD $0xf867241c // .quad -547429124662700864 + WORD $0x03c94b63; WORD $0xc30163d2 // .quad -4395122007679087773 + WORD $0xd7fc44f8; WORD $0x9b407691 // .quad -7259672230555269896 + WORD $0x425dcf1e; WORD $0x79e0de63 // .quad 8782263791269039902 + WORD $0x4dfb5636; WORD $0xc2109436 // .quad -4462904269766699466 + WORD $0x12f542e5; WORD $0x985915fc // .quad -7468914334623251739 + WORD $0xe17a2bc4; WORD $0xf294b943 // .quad -966944318780986428 + WORD $0x17b2939e; WORD $0x3e6f5b7b // .quad 4498915137003099038 + WORD $0x6cec5b5a; WORD $0x979cf3ca // .quad -7521869226879198374 + WORD $0xeecf9c43; WORD $0xa705992c // .quad -6411550076227838909 + WORD $0x08277231; WORD $0xbd8430bd // .quad -4790650515171610063 + WORD $0x2a838354; WORD $0x50c6ff78 // .quad 5820620459997365076 + WORD $0x4a314ebd; WORD $0xece53cec // .quad -1376627125537124675 + WORD $0x35246429; WORD $0xa4f8bf56 // .quad -6559282480285457367 + WORD $0xae5ed136; WORD $0x940f4613 // .quad -7777920981101784778 + WORD $0xe136be9a; WORD $0x871b7795 // .quad -8711237568605798758 + WORD $0x99f68584; WORD $0xb9131798 // .quad -5110715207949843068 + WORD $0x59846e40; WORD $0x28e2557b // .quad 2946011094524915264 + WORD $0xc07426e5; WORD $0xe757dd7e // .quad -1776707991509915931 + WORD $0x2fe589d0; WORD $0x331aeada // .quad 3682513868156144080 + WORD $0x3848984f; WORD $0x9096ea6f // .quad -8027971522334779313 + WORD $0x5def7622; WORD $0x3ff0d2c8 // .quad 4607414176811284002 + WORD $0x065abe63; WORD $0xb4bca50b // .quad -5423278384491086237 + WORD $0x756b53aa; WORD $0x0fed077a // .quad 1147581702586717098 + WORD $0xc7f16dfb; WORD $0xe1ebce4d // .quad -2167411962186469893 + WORD $0x12c62895; WORD $0xd3e84959 // .quad -3177208890193991531 + WORD $0x9cf6e4bd; WORD $0x8d3360f0 // .quad -8272161504007625539 + WORD $0xabbbd95d; WORD $0x64712dd7 // .quad 7237616480483531101 + WORD $0xc4349dec; WORD $0xb080392c // .quad -5728515861582144020 + WORD $0x96aacfb4; WORD $0xbd8d794d // .quad -4788037454677749836 + WORD $0xf541c567; WORD $0xdca04777 // .quad -2548958808550292121 + WORD $0xfc5583a1; WORD $0xecf0d7a0 // .quad -1373360799919799391 + WORD $0xf9491b60; WORD $0x89e42caa // .quad -8510628282985014432 + WORD $0x9db57245; WORD $0xf41686c4 // .quad -858350499949874619 + WORD $0xb79b6239; WORD $0xac5d37d5 // .quad -6026599335303880135 + WORD $0xc522ced6; WORD $0x311c2875 // .quad 3538747893490044630 + WORD $0x25823ac7; WORD $0xd77485cb // .quad -2921563150702462265 + WORD $0x366b828c; WORD $0x7d633293 // .quad 9035120885289943692 + WORD $0xf77164bc; WORD $0x86a8d39e // .quad -8743505996830120772 + WORD $0x02033198; WORD $0xae5dff9c // .quad -5882264492762254952 + WORD $0xb54dbdeb; WORD $0xa8530886 // .quad -6317696477610263061 + WORD $0x0283fdfd; WORD $0xd9f57f83 // .quad -2741144597525430787 + WORD $0x62a12d66; WORD $0xd267caa8 // .quad -3285434578585440922 + WORD $0xc324fd7c; WORD $0xd072df63 // .quad -3426430746906788484 + WORD $0x3da4bc60; WORD $0x8380dea9 // .quad -8970925639256982432 + WORD $0x59f71e6e; WORD $0x4247cb9e // .quad 4776009810824339054 + WORD $0x8d0deb78; WORD $0xa4611653 // .quad -6601971030643840136 + WORD $0xf074e609; WORD $0x52d9be85 // .quad 5970012263530423817 + WORD $0x70516656; WORD $0xcd795be8 // .quad -3640777769877412266 + WORD $0x6c921f8c; WORD $0x67902e27 // .quad 7462515329413029772 + WORD $0x4632dff6; WORD $0x806bd971 // .quad -9193015133814464522 + WORD $0xa3db53b7; WORD $0x00ba1cd8 // .quad 52386062455755703 + WORD $0x97bf97f3; WORD $0xa086cfcd // .quad -6879582898840692749 + WORD $0xccd228a5; WORD $0x80e8a40e // .quad -9157889458785081179 + WORD $0xfdaf7df0; WORD $0xc8a883c0 // .quad -3987792605123478032 + WORD $0x8006b2ce; WORD $0x6122cd12 // .quad 6999382250228200142 + WORD $0x3d1b5d6c; WORD $0xfad2a4b1 // .quad -373054737976959636 + WORD $0x20085f82; WORD $0x796b8057 // .quad 8749227812785250178 + WORD $0xc6311a63; WORD $0x9cc3a6ee // .quad -7150688238876681629 + WORD $0x74053bb1; WORD $0xcbe33036 // .quad -3755104653863994447 + WORD $0x77bd60fc; WORD $0xc3f490aa // .quad -4326674280168464132 + WORD $0x11068a9d; WORD $0xbedbfc44 // .quad -4693880817329993059 + WORD $0x15acb93b; WORD $0xf4f1b4d5 // .quad -796656831783192261 + WORD $0x15482d45; WORD $0xee92fb55 // .quad -1255665003235103419 + WORD $0x2d8bf3c5; WORD $0x99171105 // .quad -7415439547505577019 + WORD $0x2d4d1c4b; WORD $0x751bdd15 // .quad 8438581409832836171 + WORD $0x78eef0b6; WORD $0xbf5cd546 // .quad -4657613415954583370 + WORD $0x78a0635e; WORD $0xd262d45a // .quad -3286831292991118498 + WORD $0x172aace4; WORD $0xef340a98 // .quad -1210330751515841308 + WORD $0x16c87c35; WORD $0x86fb8971 // .quad -8720225134666286027 + WORD $0x0e7aac0e; WORD $0x9580869f // .quad -7673985747338482674 + WORD $0xae3d4da1; WORD $0xd45d35e6 // .quad -3144297699952734815 + WORD $0xd2195712; WORD $0xbae0a846 // .quad -4980796165745715438 + WORD $0x59cca10a; WORD $0x89748360 // .quad -8542058143368306422 + WORD $0x869facd7; WORD $0xe998d258 // .quad -1614309188754756393 + WORD $0x703fc94c; WORD $0x2bd1a438 // .quad 3157485376071780684 + WORD $0x5423cc06; WORD $0x91ff8377 // .quad -7926472270612804602 + WORD $0x4627ddd0; WORD $0x7b6306a3 // .quad 8890957387685944784 + WORD $0x292cbf08; WORD $0xb67f6455 // .quad -5296404319838617848 + WORD $0x17b1d543; WORD $0x1a3bc84c // .quad 1890324697752655171 + WORD $0x7377eeca; WORD $0xe41f3d6a // .quad -2008819381370884406 + WORD $0x1d9e4a94; WORD $0x20caba5f // .quad 2362905872190818964 + WORD $0x882af53e; WORD $0x8e938662 // .quad -8173041140997884610 + WORD $0x7282ee9d; WORD $0x547eb47b // .quad 6088502188546649757 + WORD $0x2a35b28d; WORD $0xb23867fb // .quad -5604615407819967859 + WORD $0x4f23aa44; WORD $0xe99e619a // .quad -1612744301171463612 + WORD $0xf4c31f31; WORD $0xdec681f9 // .quad -2394083241347571919 + WORD $0xe2ec94d5; WORD $0x6405fa00 // .quad 7207441660390446293 + WORD $0x38f9f37e; WORD $0x8b3c113c // .quad -8413831053483314306 + WORD $0x8dd3dd05; WORD $0xde83bc40 // .quad -2412877989897052923 + WORD $0x4738705e; WORD $0xae0b158b // .quad -5905602798426754978 + WORD $0xb148d446; WORD $0x9624ab50 // .quad -7627783505798704058 + WORD $0x19068c76; WORD $0xd98ddaee // .quad -2770317479606055818 + WORD $0xdd9b0958; WORD $0x3badd624 // .quad 4300328673033783640 + WORD $0xcfa417c9; WORD $0x87f8a8d4 // .quad -8648977452394866743 + WORD $0x0a80e5d7; WORD $0xe54ca5d7 // .quad -1923980597781273129 + WORD $0x038d1dbc; WORD $0xa9f6d30a // .quad -6199535797066195524 + WORD $0xcd211f4d; WORD $0x5e9fcf4c // .quad 6818396289628184397 + WORD $0x8470652b; WORD $0xd47487cc // .quad -3137733727905356501 + WORD $0x00696720; WORD $0x7647c320 // .quad 8522995362035230496 + WORD $0xd2c63f3b; WORD $0x84c8d4df // .quad -8878612607581929669 + WORD $0x0041e074; WORD $0x29ecd9f4 // .quad 3021029092058325108 + WORD $0xc777cf09; WORD $0xa5fb0a17 // .quad -6486579741050024183 + WORD $0x00525891; WORD $0xf4681071 // .quad -835399653354481519 + WORD $0xb955c2cc; WORD $0xcf79cc9d // .quad -3496538657885142324 + WORD $0x4066eeb5; WORD $0x7182148d // .quad 8179122470161673909 + WORD $0x93d599bf; WORD $0x81ac1fe2 // .quad -9102865688819295809 + WORD $0x48405531; WORD $0xc6f14cd8 // .quad -4111420493003729615 + WORD $0x38cb002f; WORD $0xa21727db // .quad -6766896092596731857 + WORD $0x5a506a7d; WORD $0xb8ada00e // .quad -5139275616254662019 + WORD $0x06fdc03b; WORD $0xca9cf1d2 // .quad -3846934097318526917 + WORD $0xf0e4851d; WORD $0xa6d90811 // .quad -6424094520318327523 + WORD $0x88bd304a; WORD $0xfd442e46 // .quad -196981603220770742 + WORD $0x6d1da664; WORD $0x908f4a16 // .quad -8030118150397909404 + WORD $0x15763e2e; WORD $0x9e4a9cec // .quad -7040642529654063570 + WORD $0x043287ff; WORD $0x9a598e4e // .quad -7324666853212387329 + WORD $0x1ad3cdba; WORD $0xc5dd4427 // .quad -4189117143640191558 + WORD $0x853f29fe; WORD $0x40eff1e1 // .quad 4679224488766679550 + WORD $0xe188c128; WORD $0xf7549530 // .quad -624710411122851544 + WORD $0xe68ef47d; WORD $0xd12bee59 // .quad -3374341425896426371 + WORD $0x8cf578b9; WORD $0x9a94dd3e // .quad -7307973034592864071 + WORD $0x301958cf; WORD $0x82bb74f8 // .quad -9026492418826348337 + WORD $0x3032d6e7; WORD $0xc13a148e // .quad -4523280274813692185 + WORD $0x3c1faf02; WORD $0xe36a5236 // .quad -2059743486678159614 + WORD $0xbc3f8ca1; WORD $0xf18899b1 // .quad -1042414325089727327 + WORD $0xcb279ac2; WORD $0xdc44e6c3 // .quad -2574679358347699518 + WORD $0x15a7b7e5; WORD $0x96f5600f // .quad -7569037980822161435 + WORD $0x5ef8c0ba; WORD $0x29ab103a // .quad 3002511419460075706 + WORD $0xdb11a5de; WORD $0xbcb2b812 // .quad -4849611457600313890 + WORD $0xf6b6f0e8; WORD $0x7415d448 // .quad 8364825292752482536 + WORD $0x91d60f56; WORD $0xebdf6617 // .quad -1450328303573004458 + WORD $0x3464ad22; WORD $0x111b495b // .quad 1232659579085827362 + WORD $0xbb25c995; WORD $0x936b9fce // .quad -7823984217374209643 + WORD $0x00beec35; WORD $0xcab10dd9 // .quad -3841273781498745803 + WORD $0x69ef3bfb; WORD $0xb84687c2 // .quad -5168294253290374149 + WORD $0x40eea743; WORD $0x3d5d514f // .quad 4421779809981343555 + WORD $0x046b0afa; WORD $0xe65829b3 // .quad -1848681798185579782 + WORD $0x112a5113; WORD $0x0cb4a5a3 // .quad 915538744049291539 + WORD $0xe2c2e6dc; WORD $0x8ff71a0f // .quad -8072955151507069220 + WORD $0xeaba72ac; WORD $0x47f0e785 // .quad 5183897733458195116 + WORD $0xdb73a093; WORD $0xb3f4e093 // .quad -5479507920956448621 + WORD $0x65690f57; WORD $0x59ed2167 // .quad 6479872166822743895 + WORD $0xd25088b8; WORD $0xe0f218b8 // .quad -2237698882768172872 + WORD $0x3ec3532d; WORD $0x306869c1 // .quad 3488154190101041965 + WORD $0x83725573; WORD $0x8c974f73 // .quad -8316090829371189901 + WORD $0xc73a13fc; WORD $0x1e414218 // .quad 2180096368813151228 + WORD $0x644eeacf; WORD $0xafbd2350 // .quad -5783427518286599473 + WORD $0xf90898fb; WORD $0xe5d1929e // .quad -1886565557410948869 + WORD $0x7d62a583; WORD $0xdbac6c24 // .quad -2617598379430861437 + WORD $0xb74abf3a; WORD $0xdf45f746 // .quad -2358206946763686086 + WORD $0xce5da772; WORD $0x894bc396 // .quad -8553528014785370254 + WORD $0x328eb784; WORD $0x6b8bba8c // .quad 7749492695127472004 + WORD $0x81f5114f; WORD $0xab9eb47c // .quad -6080224000054324913 + WORD $0x3f326565; WORD $0x066ea92f // .quad 463493832054564197 + WORD $0xa27255a2; WORD $0xd686619b // .quad -2988593981640518238 + WORD $0x0efefebe; WORD $0xc80a537b // .quad -4032318728359182658 + WORD $0x45877585; WORD $0x8613fd01 // .quad -8785400266166405755 + WORD $0xe95f5f37; WORD $0xbd06742c // .quad -4826042214438183113 + WORD $0x96e952e7; WORD $0xa798fc41 // .quad -6370064314280619289 + WORD $0x23b73705; WORD $0x2c481138 // .quad 3190819268807046917 + WORD $0xfca3a7a0; WORD $0xd17f3b51 // .quad -3350894374423386208 + WORD $0x2ca504c6; WORD $0xf75a1586 // .quad -623161932418579258 + WORD $0x3de648c4; WORD $0x82ef8513 // .quad -9011838011655698236 + WORD $0xdbe722fc; WORD $0x9a984d73 // .quad -7307005235402693892 + WORD $0x0d5fdaf5; WORD $0xa3ab6658 // .quad -6653111496142234891 + WORD $0xd2e0ebbb; WORD $0xc13e60d0 // .quad -4522070525825979461 + WORD $0x10b7d1b3; WORD $0xcc963fee // .quad -3704703351750405709 + WORD $0x079926a9; WORD $0x318df905 // .quad 3570783879572301481 + WORD $0x94e5c61f; WORD $0xffbbcfe9 // .quad -19193171260619233 + WORD $0x497f7053; WORD $0xfdf17746 // .quad -148206168962011053 + WORD $0xfd0f9bd3; WORD $0x9fd561f1 // .quad -6929524759678968877 + WORD $0xedefa634; WORD $0xfeb6ea8b // .quad -92628855601256908 + WORD $0x7c5382c8; WORD $0xc7caba6e // .quad -4050219931171323192 + WORD $0xe96b8fc1; WORD $0xfe64a52e // .quad -115786069501571135 + WORD $0x1b68637b; WORD $0xf9bd690a // .quad -451088895536766085 + WORD $0xa3c673b1; WORD $0x3dfdce7a // .quad 4466953431550423985 + WORD $0x51213e2d; WORD $0x9c1661a6 // .quad -7199459587351560659 + WORD $0xa65c084f; WORD $0x06bea10c // .quad 486002885505321039 + WORD $0xe5698db8; WORD $0xc31bfa0f // .quad -4387638465762062920 + WORD $0xcff30a63; WORD $0x486e494f // .quad 5219189625309039203 + WORD $0xdec3f126; WORD $0xf3e2f893 // .quad -872862063775190746 + WORD $0xc3efccfb; WORD $0x5a89dba3 // .quad 6523987031636299003 + WORD $0x6b3a76b7; WORD $0x986ddb5c // .quad -7463067817500576073 + WORD $0x5a75e01d; WORD $0xf8962946 // .quad -534194123654701027 + WORD $0x86091465; WORD $0xbe895233 // .quad -4717148753448332187 + WORD $0xf1135824; WORD $0xf6bbb397 // .quad -667742654568376284 + WORD $0x678b597f; WORD $0xee2ba6c0 // .quad -1284749923383027329 + WORD $0xed582e2d; WORD $0x746aa07d // .quad 8388693718644305453 + WORD $0x40b717ef; WORD $0x94db4838 // .quad -7720497729755473937 + WORD $0xb4571cdd; WORD $0xa8c2a44e // .quad -6286281471915778851 + WORD $0x50e4ddeb; WORD $0xba121a46 // .quad -5038936143766954517 + WORD $0x616ce414; WORD $0x92f34d62 // .quad -7857851839894723564 + WORD $0xe51e1566; WORD $0xe896a0d7 // .quad -1686984161281305242 + WORD $0xf9c81d18; WORD $0x77b020ba // .quad 8624429273841147160 + WORD $0xef32cd60; WORD $0x915e2486 // .quad -7971894128441897632 + WORD $0xdc1d122f; WORD $0x0ace1474 // .quad 778582277723329071 + WORD $0xaaff80b8; WORD $0xb5b5ada8 // .quad -5353181642124984136 + WORD $0x132456bb; WORD $0x0d819992 // .quad 973227847154161339 + WORD $0xd5bf60e6; WORD $0xe3231912 // .quad -2079791034228842266 + WORD $0x97ed6c6a; WORD $0x10e1fff6 // .quad 1216534808942701674 + WORD $0xc5979c8f; WORD $0x8df5efab // .quad -8217398424034108273 + WORD $0x1ef463c2; WORD $0xca8d3ffa // .quad -3851351762838199358 + WORD $0xb6fd83b3; WORD $0xb1736b96 // .quad -5660062011615247437 + WORD $0xa6b17cb3; WORD $0xbd308ff8 // .quad -4814189703547749197 + WORD $0x64bce4a0; WORD $0xddd0467c // .quad -2463391496091671392 + WORD $0xd05ddbdf; WORD $0xac7cb3f6 // .quad -6017737129434686497 + WORD $0xbef60ee4; WORD $0x8aa22c0d // .quad -8457148712698376476 + WORD $0x423aa96c; WORD $0x6bcdf07a // .quad 7768129340171790700 + WORD $0x2eb3929d; WORD $0xad4ab711 // .quad -5959749872445582691 + WORD $0xd2c953c7; WORD $0x86c16c98 // .quad -8736582398494813241 + WORD $0x7a607744; WORD $0xd89d64d5 // .quad -2838001322129590460 + WORD $0x077ba8b8; WORD $0xe871c7bf // .quad -1697355961263740744 + WORD $0x6c7c4a8b; WORD $0x87625f05 // .quad -8691279853972075893 + WORD $0x64ad4973; WORD $0x11471cd7 // .quad 1244995533423855987 + WORD $0xc79b5d2d; WORD $0xa93af6c6 // .quad -6252413799037706963 + WORD $0x3dd89bd0; WORD $0xd598e40d // .quad -3055441601647567920 + WORD $0x79823479; WORD $0xd389b478 // .quad -3203831230369745799 + WORD $0x8d4ec2c4; WORD $0x4aff1d10 // .quad 5404070034795315908 + WORD $0x4bf160cb; WORD $0x843610cb // .quad -8919923546622172981 + WORD $0x585139bb; WORD $0xcedf722a // .quad -3539985255894009413 + WORD $0x1eedb8fe; WORD $0xa54394fe // .quad -6538218414850328322 + WORD $0xee658829; WORD $0xc2974eb4 // .quad -4424981569867511767 + WORD $0xa6a9273e; WORD $0xce947a3d // .quad -3561087000135522498 + WORD $0x29feea33; WORD $0x733d2262 // .quad 8303831092947774003 + WORD $0x8829b887; WORD $0x811ccc66 // .quad -9143208402725783417 + WORD $0x5a3f5260; WORD $0x0806357d // .quad 578208414664970848 + WORD $0x2a3426a8; WORD $0xa163ff80 // .quad -6817324484979841368 + WORD $0xb0cf26f8; WORD $0xca07c2dc // .quad -3888925500096174344 + WORD $0x34c13052; WORD $0xc9bcff60 // .quad -3909969587797413806 + WORD $0xdd02f0b6; WORD $0xfc89b393 // .quad -249470856692830026 + WORD $0x41f17c67; WORD $0xfc2c3f38 // .quad -275775966319379353 + WORD $0xd443ace3; WORD $0xbbac2078 // .quad -4923524589293425437 + WORD $0x2936edc0; WORD $0x9d9ba783 // .quad -7089889006590693952 + WORD $0x84aa4c0e; WORD $0xd54b944b // .quad -3077202868308390898 + WORD $0xf384a931; WORD $0xc5029163 // .quad -4250675239810979535 + WORD $0x65d4df12; WORD $0x0a9e795e // .quad 765182433041899282 + WORD $0xf065d37d; WORD $0xf64335bc // .quad -701658031336336515 + WORD $0xff4a16d6; WORD $0x4d4617b5 // .quad 5568164059729762006 + WORD $0x163fa42e; WORD $0x99ea0196 // .quad -7356065297226292178 + WORD $0xbf8e4e46; WORD $0x504bced1 // .quad 5785945546544795206 + WORD $0x9bcf8d39; WORD $0xc06481fb // .quad -4583395603105477319 + WORD $0x2f71e1d7; WORD $0xe45ec286 // .quad -1990940103673781801 + WORD $0x82c37088; WORD $0xf07da27a // .quad -1117558485454458744 + WORD $0xbb4e5a4d; WORD $0x5d767327 // .quad 6734696907262548557 + WORD $0x91ba2655; WORD $0x964e858c // .quad -7616003081050118571 + WORD $0xd510f870; WORD $0x3a6a07f8 // .quad 4209185567039092848 + WORD $0xb628afea; WORD $0xbbe226ef // .quad -4908317832885260310 + WORD $0x0a55368c; WORD $0x890489f7 // .quad -8573576096483297652 + WORD $0xa3b2dbe5; WORD $0xeadab0ab // .quad -1523711272679187483 + WORD $0xccea842f; WORD $0x2b45ac74 // .quad 3118087934678041647 + WORD $0x464fc96f; WORD $0x92c8ae6b // .quad -7869848573065574033 + WORD $0x0012929e; WORD $0x3b0b8bc9 // .quad 4254647968387469982 + WORD $0x17e3bbcb; WORD $0xb77ada06 // .quad -5225624697904579637 + WORD $0x40173745; WORD $0x09ce6ebb // .quad 706623942056949573 + WORD $0x9ddcaabd; WORD $0xe5599087 // .quad -1920344853953336643 + WORD $0x101d0516; WORD $0xcc420a6a // .quad -3728406090856200938 + WORD $0xc2a9eab6; WORD $0x8f57fa54 // .quad -8117744561361917258 + WORD $0x4a12232e; WORD $0x9fa94682 // .quad -6941939825212513490 + WORD $0xf3546564; WORD $0xb32df8e9 // .quad -5535494683275008668 + WORD $0xdc96abfa; WORD $0x47939822 // .quad 5157633273766521850 + WORD $0x70297ebd; WORD $0xdff97724 // .quad -2307682335666372931 + WORD $0x93bc56f8; WORD $0x59787e2b // .quad 6447041592208152312 + WORD $0xc619ef36; WORD $0x8bfbea76 // .quad -8359830487432564938 + WORD $0x3c55b65b; WORD $0x57eb4edb // .quad 6335244004343789147 + WORD $0x77a06b03; WORD $0xaefae514 // .quad -5838102090863318269 + WORD $0x0b6b23f2; WORD $0xede62292 // .quad -1304317031425039374 + WORD $0x958885c4; WORD $0xdab99e59 // .quad -2685941595151759932 + WORD $0x8e45ecee; WORD $0xe95fab36 // .quad -1630396289281299218 + WORD $0xfd75539b; WORD $0x88b402f7 // .quad -8596242524610931813 + WORD $0x18ebb415; WORD $0x11dbcb02 // .quad 1286845328412881941 + WORD $0xfcd2a881; WORD $0xaae103b5 // .quad -6133617137336276863 + WORD $0x9f26a11a; WORD $0xd652bdc2 // .quad -3003129357911285478 + WORD $0x7c0752a2; WORD $0xd59944a3 // .quad -3055335403242958174 + WORD $0x46f04960; WORD $0x4be76d33 // .quad 5469460339465668960 + WORD $0x2d8493a5; WORD $0x857fcae6 // .quad -8827113654667930715 + WORD $0x0c562ddc; WORD $0x6f70a440 // .quad 8030098730593431004 + WORD $0xb8e5b88e; WORD $0xa6dfbd9f // .quad -6422206049907525490 + WORD $0x0f6bb953; WORD $0xcb4ccd50 // .quad -3797434642040374957 + WORD $0xa71f26b2; WORD $0xd097ad07 // .quad -3416071543957018958 + WORD $0x1346a7a8; WORD $0x7e2000a4 // .quad 9088264752731695016 + WORD $0xc873782f; WORD $0x825ecc24 // .quad -9052573742614218705 + WORD $0x8c0c28c9; WORD $0x8ed40066 // .quad -8154892584824854327 + WORD $0xfa90563b; WORD $0xa2f67f2d // .quad -6704031159840385477 + WORD $0x2f0f32fb; WORD $0x72890080 // .quad 8253128342678483707 + WORD $0x79346bca; WORD $0xcbb41ef9 // .quad -3768352931373093942 + WORD $0x3ad2ffba; WORD $0x4f2b40a0 // .quad 5704724409920716730 + WORD $0xd78186bc; WORD $0xfea126b7 // .quad -98755145788979524 + WORD $0x4987bfa9; WORD $0xe2f610c8 // .quad -2092466524453879895 + WORD $0xe6b0f436; WORD $0x9f24b832 // .quad -6979250993759194058 + WORD $0x2df4d7ca; WORD $0x0dd9ca7d // .quad 998051431430019018 + WORD $0xa05d3143; WORD $0xc6ede63f // .quad -4112377723771604669 + WORD $0x79720dbc; WORD $0x91503d1c // .quad -7975807747567252036 + WORD $0x88747d94; WORD $0xf8a95fcf // .quad -528786136287117932 + WORD $0x97ce912b; WORD $0x75a44c63 // .quad 8476984389250486571 + WORD $0xb548ce7c; WORD $0x9b69dbe1 // .quad -7248020362820530564 + WORD $0x3ee11abb; WORD $0xc986afbe // .quad -3925256793573221701 + WORD $0x229b021b; WORD $0xc24452da // .quad -4448339435098275301 + WORD $0xce996169; WORD $0xfbe85bad // .quad -294884973539139223 + WORD $0xab41c2a2; WORD $0xf2d56790 // .quad -948738275445456222 + WORD $0x423fb9c4; WORD $0xfae27299 // .quad -368606216923924028 + WORD $0x6b0919a5; WORD $0x97c560ba // .quad -7510490449794491995 + WORD $0xc967d41b; WORD $0xdccd879f // .quad -2536221894791146469 + WORD $0x05cb600f; WORD $0xbdb6b8e9 // .quad -4776427043815727089 + WORD $0xbbc1c921; WORD $0x5400e987 // .quad 6053094668365842721 + WORD $0x473e3813; WORD $0xed246723 // .quad -1358847786342270957 + WORD $0xaab23b69; WORD $0x290123e9 // .quad 2954682317029915497 + WORD $0x0c86e30b; WORD $0x9436c076 // .quad -7766808894105001205 + WORD $0x0aaf6522; WORD $0xf9a0b672 // .quad -459166561069996766 + WORD $0x8fa89bce; WORD $0xb9447093 // .quad -5096825099203863602 + WORD $0x8d5b3e6a; WORD $0xf808e40e // .quad -573958201337495958 + WORD $0x7392c2c2; WORD $0xe7958cb8 // .quad -1759345355577441598 + WORD $0x30b20e05; WORD $0xb60b1d12 // .quad -5329133770099257851 + WORD $0x483bb9b9; WORD $0x90bd77f3 // .quad -8017119874876982855 + WORD $0x5e6f48c3; WORD $0xb1c6f22b // .quad -5636551615525730109 + WORD $0x1a4aa828; WORD $0xb4ecd5f0 // .quad -5409713825168840664 + WORD $0x360b1af4; WORD $0x1e38aeb6 // .quad 2177682517447613172 + WORD $0x20dd5232; WORD $0xe2280b6c // .quad -2150456263033662926 + WORD $0xc38de1b1; WORD $0x25c6da63 // .quad 2722103146809516465 + WORD $0x948a535f; WORD $0x8d590723 // .quad -8261564192037121185 + WORD $0x5a38ad0f; WORD $0x579c487e // .quad 6313000485183335695 + WORD $0x79ace837; WORD $0xb0af48ec // .quad -5715269221619013577 + WORD $0xf0c6d852; WORD $0x2d835a9d // .quad 3279564588051781714 + WORD $0x98182244; WORD $0xdcdb1b27 // .quad -2532400508596379068 + WORD $0x6cf88e66; WORD $0xf8e43145 // .quad -512230283362660762 + WORD $0xbf0f156b; WORD $0x8a08f0f8 // .quad -8500279345513818773 + WORD $0x641b5900; WORD $0x1b8e9ecb // .quad 1985699082112030976 + WORD $0xeed2dac5; WORD $0xac8b2d36 // .quad -6013663163464885563 + WORD $0x3d222f40; WORD $0xe272467e // .quad -2129562165787349184 + WORD $0xaa879177; WORD $0xd7adf884 // .quad -2905392935903719049 + WORD $0xcc6abb10; WORD $0x5b0ed81d // .quad 6561419329620589328 + WORD $0xea94baea; WORD $0x86ccbb52 // .quad -8733399612580906262 + WORD $0x9fc2b4ea; WORD $0x98e94712 // .quad -7428327965055601430 + WORD $0xa539e9a5; WORD $0xa87fea27 // .quad -6305063497298744923 + WORD $0x47b36225; WORD $0x3f2398d7 // .quad 4549648098962661925 + WORD $0x8e88640e; WORD $0xd29fe4b1 // .quad -3269643353196043250 + WORD $0x19a03aae; WORD $0x8eec7f0d // .quad -8147997931578836306 + WORD $0xf9153e89; WORD $0x83a3eeee // .quad -8961056123388608887 + WORD $0x300424ad; WORD $0x1953cf68 // .quad 1825030320404309165 + WORD $0xb75a8e2b; WORD $0xa48ceaaa // .quad -6589634135808373205 + WORD $0x3c052dd8; WORD $0x5fa8c342 // .quad 6892973918932774360 + WORD $0x653131b6; WORD $0xcdb02555 // .quad -3625356651333078602 + WORD $0xcb06794e; WORD $0x3792f412 // .quad 4004531380238580046 + WORD $0x5f3ebf11; WORD $0x808e1755 // .quad -9183376934724255983 + WORD $0xbee40bd1; WORD $0xe2bbd88b // .quad -2108853905778275375 + WORD $0xb70e6ed6; WORD $0xa0b19d2a // .quad -6867535149977932074 + WORD $0xae9d0ec5; WORD $0x5b6aceae // .quad 6587304654631931589 + WORD $0x64d20a8b; WORD $0xc8de0475 // .quad -3972732919045027189 + WORD $0x5a445276; WORD $0xf245825a // .quad -989241218564861322 + WORD $0xbe068d2e; WORD $0xfb158592 // .quad -354230130378896082 + WORD $0xf0d56713; WORD $0xeed6e2f0 // .quad -1236551523206076653 + WORD $0xb6c4183d; WORD $0x9ced737b // .quad -7138922859127891907 + WORD $0x9685606c; WORD $0x55464dd6 // .quad 6144684325637283948 + WORD $0xa4751e4c; WORD $0xc428d05a // .quad -4311967555482476980 + WORD $0x3c26b887; WORD $0xaa97e14c // .quad -6154202648235558777 + WORD $0x4d9265df; WORD $0xf5330471 // .quad -778273425925708321 + WORD $0x4b3066a9; WORD $0xd53dd99f // .quad -3081067291867060567 + WORD $0xd07b7fab; WORD $0x993fe2c6 // .quad -7403949918844649557 + WORD $0x8efe402a; WORD $0xe546a803 // .quad -1925667057416912854 + WORD $0x849a5f96; WORD $0xbf8fdb78 // .quad -4643251380128424042 + WORD $0x72bdd034; WORD $0xde985204 // .quad -2407083821771141068 + WORD $0xa5c0f77c; WORD $0xef73d256 // .quad -1192378206733142148 + WORD $0x8f6d4441; WORD $0x963e6685 // .quad -7620540795641314239 + WORD $0x27989aad; WORD $0x95a86376 // .quad -7662765406849295699 + WORD $0x79a44aa9; WORD $0xdde70013 // .quad -2456994988062127447 + WORD $0xb17ec159; WORD $0xbb127c53 // .quad -4966770740134231719 + WORD $0x580d5d53; WORD $0x5560c018 // .quad 6152128301777116499 + WORD $0x9dde71af; WORD $0xe9d71b68 // .quad -1596777406740401745 + WORD $0x6e10b4a7; WORD $0xaab8f01e // .quad -6144897678060768089 + WORD $0x62ab070d; WORD $0x92267121 // .quad -7915514906853832947 + WORD $0x04ca70e9; WORD $0xcab39613 // .quad -3840561048787980055 + WORD $0xbb55c8d1; WORD $0xb6b00d69 // .quad -5282707615139903279 + WORD $0xc5fd0d23; WORD $0x3d607b97 // .quad 4422670725869800739 + WORD $0x2a2b3b05; WORD $0xe45c10c4 // .quad -1991698500497491195 + WORD $0xb77c506b; WORD $0x8cb89a7d // .quad -8306719647944912789 + WORD $0x9a5b04e3; WORD $0x8eb98a7a // .quad -8162340590452013853 + WORD $0x92adb243; WORD $0x77f3608e // .quad 8643358275316593219 + WORD $0x40f1c61c; WORD $0xb267ed19 // .quad -5591239719637629412 + WORD $0x37591ed4; WORD $0x55f038b2 // .quad 6192511825718353620 + WORD $0x912e37a3; WORD $0xdf01e85f // .quad -2377363631119648861 + WORD $0xc52f6689; WORD $0x6b6c46de // .quad 7740639782147942025 + WORD $0xbabce2c6; WORD $0x8b61313b // .quad -8403381297090862394 + WORD $0x3b3da016; WORD $0x2323ac4b // .quad 2532056854628769814 + WORD $0xa96c1b77; WORD $0xae397d8a // .quad -5892540602936190089 + WORD $0x0a0d081b; WORD $0xabec975e // .quad -6058300968568813541 + WORD $0x53c72255; WORD $0xd9c7dced // .quad -2753989735242849707 + WORD $0x8c904a22; WORD $0x96e7bd35 // .quad -7572876210711016926 + WORD $0x545c7575; WORD $0x881cea14 // .quad -8638772612167862923 + WORD $0x77da2e55; WORD $0x7e50d641 // .quad 9102010423587778133 + WORD $0x697392d2; WORD $0xaa242499 // .quad -6186779746782440750 + WORD $0xd5d0b9ea; WORD $0xdde50bd1 // .quad -2457545025797441046 + WORD $0xc3d07787; WORD $0xd4ad2dbf // .quad -3121788665050663033 + WORD $0x4b44e865; WORD $0x955e4ec6 // .quad -7683617300674189211 + WORD $0xda624ab4; WORD $0x84ec3c97 // .quad -8868646943297746252 + WORD $0xef0b113f; WORD $0xbd5af13b // .quad -4802260812921368257 + WORD $0xd0fadd61; WORD $0xa6274bbd // .quad -6474122660694794911 + WORD $0xeacdd58f; WORD $0xecb1ad8a // .quad -1391139997724322417 + WORD $0x453994ba; WORD $0xcfb11ead // .quad -3480967307441105734 + WORD $0xa5814af3; WORD $0x67de18ed // .quad 7484447039699372787 + WORD $0x4b43fcf4; WORD $0x81ceb32c // .quad -9093133594791772940 + WORD $0x8770ced8; WORD $0x80eacf94 // .quad -9157278655470055720 + WORD $0x5e14fc31; WORD $0xa2425ff7 // .quad -6754730975062328271 + WORD $0xa94d028e; WORD $0xa1258379 // .quad -6834912300910181746 + WORD $0x359a3b3e; WORD $0xcad2f7f5 // .quad -3831727700400522434 + WORD $0x13a04331; WORD $0x096ee458 // .quad 679731660717048625 + WORD $0x8300ca0d; WORD $0xfd87b5f2 // .quad -177973607073265139 + WORD $0x188853fd; WORD $0x8bca9d6e // .quad -8373707460958465027 + WORD $0x91e07e48; WORD $0x9e74d1b7 // .quad -7028762532061872568 + WORD $0xcf55347e; WORD $0x775ea264 // .quad 8601490892183123070 + WORD $0x76589dda; WORD $0xc6120625 // .quad -4174267146649952806 + WORD $0x032a819e; WORD $0x95364afe // .quad -7694880458480647778 + WORD $0xd3eec551; WORD $0xf79687ae // .quad -606147914885053103 + WORD $0x83f52205; WORD $0x3a83ddbd // .quad 4216457482181353989 + WORD $0x44753b52; WORD $0x9abe14cd // .quad -7296371474444240046 + WORD $0x72793543; WORD $0xc4926a96 // .quad -4282243101277735613 + WORD $0x95928a27; WORD $0xc16d9a00 // .quad -4508778324627912153 + WORD $0x0f178294; WORD $0x75b7053c // .quad 8482254178684994196 + WORD $0xbaf72cb1; WORD $0xf1c90080 // .quad -1024286887357502287 + WORD $0x12dd6339; WORD $0x5324c68b // .quad 5991131704928854841 + WORD $0x74da7bee; WORD $0x971da050 // .quad -7557708332239520786 + WORD $0xebca5e04; WORD $0xd3f6fc16 // .quad -3173071712060547580 + WORD $0x92111aea; WORD $0xbce50864 // .quad -4835449396872013078 + WORD $0xa6bcf585; WORD $0x88f4bb1c // .quad -8578025658503072379 + WORD $0xb69561a5; WORD $0xec1e4a7d // .quad -1432625727662628443 + WORD $0xd06c32e6; WORD $0x2b31e9e3 // .quad 3112525982153323238 + WORD $0x921d5d07; WORD $0x9392ee8e // .quad -7812920107430224633 + WORD $0x62439fd0; WORD $0x3aff322e // .quad 4251171748059520976 + WORD $0x36a4b449; WORD $0xb877aa32 // .quad -5154464115860392887 + WORD $0xfad487c3; WORD $0x09befeb9 // .quad 702278666647013315 + WORD $0xc44de15b; WORD $0xe69594be // .quad -1831394126398103205 + WORD $0x7989a9b4; WORD $0x4c2ebe68 // .quad 5489534351736154548 + WORD $0x3ab0acd9; WORD $0x901d7cf7 // .quad -8062150356639896359 + WORD $0x4bf60a11; WORD $0x0f9d3701 // .quad 1125115960621402641 + WORD $0x095cd80f; WORD $0xb424dc35 // .quad -5466001927372482545 + WORD $0x9ef38c95; WORD $0x538484c1 // .quad 6018080969204141205 + WORD $0x4bb40e13; WORD $0xe12e1342 // .quad -2220816390788215277 + WORD $0x06b06fba; WORD $0x2865a5f2 // .quad 2910915193077788602 + WORD $0x6f5088cb; WORD $0x8cbccc09 // .quad -8305539271883716405 + WORD $0x442e45d4; WORD $0xf93f87b7 // .quad -486521013540076076 + WORD $0xcb24aafe; WORD $0xafebff0b // .quad -5770238071427257602 + WORD $0x1539d749; WORD $0xf78f69a5 // .quad -608151266925095095 + WORD $0xbdedd5be; WORD $0xdbe6fece // .quad -2601111570856684098 + WORD $0x5a884d1c; WORD $0xb573440e // .quad -5371875102083756772 + WORD $0x36b4a597; WORD $0x89705f41 // .quad -8543223759426509417 + WORD $0xf8953031; WORD $0x31680a88 // .quad 3560107088838733873 + WORD $0x8461cefc; WORD $0xabcc7711 // .quad -6067343680855748868 + WORD $0x36ba7c3e; WORD $0xfdc20d2b // .quad -161552157378970562 + WORD $0xe57a42bc; WORD $0xd6bf94d5 // .quad -2972493582642298180 + WORD $0x04691b4d; WORD $0x3d329076 // .quad 4409745821703674701 + WORD $0xaf6c69b5; WORD $0x8637bd05 // .quad -8775337516792518219 + WORD $0xc2c1b110; WORD $0xa63f9a49 // .quad -6467280898289979120 + WORD $0x1b478423; WORD $0xa7c5ac47 // .quad -6357485877563259869 + WORD $0x33721d54; WORD $0x0fcf80dc // .quad 1139270913992301908 + WORD $0xe219652b; WORD $0xd1b71758 // .quad -3335171328526686933 + WORD $0x404ea4a9; WORD $0xd3c36113 // .quad -3187597375937010519 + WORD $0x8d4fdf3b; WORD $0x83126e97 // .quad -9002011107970261189 + WORD $0x083126ea; WORD $0x645a1cac // .quad 7231123676894144234 + WORD $0x70a3d70a; WORD $0xa3d70a3d // .quad -6640827866535438582 + WORD $0x0a3d70a4; WORD $0x3d70a3d7 // .quad 4427218577690292388 + WORD $0xcccccccc; WORD $0xcccccccc // .quad -3689348814741910324 + WORD $0xcccccccd; WORD $0xcccccccc // .quad -3689348814741910323 + WORD $0x00000000; WORD $0x80000000 // .quad -9223372036854775808 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xa0000000 // .quad -6917529027641081856 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xc8000000 // .quad -4035225266123964416 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xfa000000 // .quad -432345564227567616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x9c400000 // .quad -7187745005283311616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xc3500000 // .quad -4372995238176751616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xf4240000 // .quad -854558029293551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x98968000 // .quad -7451627795949551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xbebc2000 // .quad -4702848726509551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xee6b2800 // .quad -1266874889709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x9502f900 // .quad -7709325833709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xba43b740 // .quad -5024971273709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xe8d4a510 // .quad -1669528073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x9184e72a // .quad -7960984073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x80000000; WORD $0xb5e620f4 // .quad -5339544073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xa0000000; WORD $0xe35fa931 // .quad -2062744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x04000000; WORD $0x8e1bc9bf // .quad -8206744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xc5000000; WORD $0xb1a2bc2e // .quad -5646744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x76400000; WORD $0xde0b6b3a // .quad -2446744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x89e80000; WORD $0x8ac72304 // .quad -8446744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xac620000; WORD $0xad78ebc5 // .quad -5946744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x177a8000; WORD $0xd8d726b7 // .quad -2821744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x6eac9000; WORD $0x87867832 // .quad -8681119073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x0a57b400; WORD $0xa968163f // .quad -6239712823709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xcceda100; WORD $0xd3c21bce // .quad -3187955011209551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x401484a0; WORD $0x84595161 // .quad -8910000909647051616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x9019a5c8; WORD $0xa56fa5b9 // .quad -6525815118631426616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xf4200f3a; WORD $0xcecb8f27 // .quad -3545582879861895366 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xf8940984; WORD $0x813f3978 // .quad -9133518327554766460 + WORD $0x00000000; WORD $0x40000000 // .quad 4611686018427387904 + WORD $0x36b90be5; WORD $0xa18f07d7 // .quad -6805211891016070171 + WORD $0x00000000; WORD $0x50000000 // .quad 5764607523034234880 + WORD $0x04674ede; WORD $0xc9f2c9cd // .quad -3894828845342699810 + WORD $0x00000000; WORD $0xa4000000 // .quad -6629298651489370112 + WORD $0x45812296; WORD $0xfc6f7c40 // .quad -256850038250986858 + WORD $0x00000000; WORD $0x4d000000 // .quad 5548434740920451072 + WORD $0x2b70b59d; WORD $0x9dc5ada8 // .quad -7078060301547948643 + WORD $0x00000000; WORD $0xf0200000 // .quad -1143914305352105984 + WORD $0x364ce305; WORD $0xc5371912 // .quad -4235889358507547899 + WORD $0x00000000; WORD $0x6c280000 // .quad 7793479155164643328 + WORD $0xc3e01bc6; WORD $0xf684df56 // .quad -683175679707046970 + WORD $0x00000000; WORD $0xc7320000 // .quad -4093209111326359552 + WORD $0x3a6c115c; WORD $0x9a130b96 // .quad -7344513827457986212 + WORD $0x00000000; WORD $0x3c7f4000 // .quad 4359273333062107136 + WORD $0xc90715b3; WORD $0xc097ce7b // .quad -4568956265895094861 + WORD $0x00000000; WORD $0x4b9f1000 // .quad 5449091666327633920 + WORD $0xbb48db20; WORD $0xf0bdc21a // .quad -1099509313941480672 + WORD $0x00000000; WORD $0x1e86d400 // .quad 2199678564482154496 + WORD $0xb50d88f4; WORD $0x96769950 // .quad -7604722348854507276 + WORD $0x00000000; WORD $0x13144480 // .quad 1374799102801346560 + WORD $0xe250eb31; WORD $0xbc143fa4 // .quad -4894216917640746191 + WORD $0x00000000; WORD $0x17d955a0 // .quad 1718498878501683200 + WORD $0x1ae525fd; WORD $0xeb194f8e // .quad -1506085128623544835 + WORD $0x00000000; WORD $0x5dcfab08 // .quad 6759809616554491904 + WORD $0xd0cf37be; WORD $0x92efd1b8 // .quad -7858832233030797378 + WORD $0x00000000; WORD $0x5aa1cae5 // .quad 6530724019560251392 + WORD $0x050305ad; WORD $0xb7abc627 // .quad -5211854272861108819 + WORD $0x40000000; WORD $0xf14a3d9e // .quad -1059967012404461568 + WORD $0xc643c719; WORD $0xe596b7b0 // .quad -1903131822648998119 + WORD $0xd0000000; WORD $0x6d9ccd05 // .quad 7898413271349198848 + WORD $0x7bea5c6f; WORD $0x8f7e32ce // .quad -8106986416796705681 + WORD $0xa2000000; WORD $0xe4820023 // .quad -1981020733047832576 + WORD $0x1ae4f38b; WORD $0xb35dbf82 // .quad -5522047002568494197 + WORD $0x8a800000; WORD $0xdda2802c // .quad -2476275916309790720 + WORD $0xa19e306e; WORD $0xe0352f62 // .quad -2290872734783229842 + WORD $0xad200000; WORD $0xd50b2037 // .quad -3095344895387238400 + WORD $0xa502de45; WORD $0x8c213d9d // .quad -8349324486880600507 + WORD $0xcc340000; WORD $0x4526f422 // .quad 4982938468024057856 + WORD $0x0e4395d6; WORD $0xaf298d05 // .quad -5824969590173362730 + WORD $0x7f410000; WORD $0x9670b12b // .quad -7606384970252091392 + WORD $0x51d47b4c; WORD $0xdaf3f046 // .quad -2669525969289315508 + WORD $0x5f114000; WORD $0x3c0cdd76 // .quad 4327076842467049472 + WORD $0xf324cd0f; WORD $0x88d8762b // .quad -8585982758446904049 + WORD $0xfb6ac800; WORD $0xa5880a69 // .quad -6518949010312869888 + WORD $0xefee0053; WORD $0xab0e93b6 // .quad -6120792429631242157 + WORD $0x7a457a00; WORD $0x8eea0d04 // .quad -8148686262891087360 + WORD $0xabe98068; WORD $0xd5d238a4 // .quad -3039304518611664792 + WORD $0x98d6d880; WORD $0x72a49045 // .quad 8260886245095692416 + WORD $0xeb71f041; WORD $0x85a36366 // .quad -8817094351773372351 + WORD $0x7f864750; WORD $0x47a6da2b // .quad 5163053903184807760 + WORD $0xa64e6c51; WORD $0xa70c3c40 // .quad -6409681921289327535 + WORD $0x5f67d924; WORD $0x999090b6 // .quad -7381240676301154012 + WORD $0xcfe20765; WORD $0xd0cf4b50 // .quad -3400416383184271515 + WORD $0xf741cf6d; WORD $0xfff4b4e3 // .quad -3178808521666707 + WORD $0x81ed449f; WORD $0x82818f12 // .quad -9042789267131251553 + WORD $0x7a8921a5; WORD $0xbff8f10e // .quad -4613672773753429595 + WORD $0x226895c7; WORD $0xa321f2d7 // .quad -6691800565486676537 + WORD $0x192b6a0e; WORD $0xaff72d52 // .quad -5767090967191786994 + WORD $0xeb02bb39; WORD $0xcbea6f8c // .quad -3753064688430957767 + WORD $0x9f764491; WORD $0x9bf4f8a6 // .quad -7208863708989733743 + WORD $0x25c36a08; WORD $0xfee50b70 // .quad -79644842111309304 + WORD $0x4753d5b5; WORD $0x02f236d0 // .quad 212292400617608629 + WORD $0x179a2245; WORD $0x9f4f2726 // .quad -6967307053960650171 + WORD $0x2c946591; WORD $0x01d76242 // .quad 132682750386005393 + WORD $0x9d80aad6; WORD $0xc722f0ef // .quad -4097447799023424810 + WORD $0xb7b97ef6; WORD $0x424d3ad2 // .quad 4777539456409894646 + WORD $0x84e0d58b; WORD $0xf8ebad2b // .quad -510123730351893109 + WORD $0x65a7deb3; WORD $0xd2e08987 // .quad -3251447716342407501 + WORD $0x330c8577; WORD $0x9b934c3b // .quad -7236356359111015049 + WORD $0x9f88eb30; WORD $0x63cc55f4 // .quad 7191217214140771120 + WORD $0xffcfa6d5; WORD $0xc2781f49 // .quad -4433759430461380907 + WORD $0xc76b25fc; WORD $0x3cbf6b71 // .quad 4377335499248575996 + WORD $0x7fc3908a; WORD $0xf316271c // .quad -930513269649338230 + WORD $0x3945ef7b; WORD $0x8bef464e // .quad -8363388681221443717 + WORD $0xcfda3a56; WORD $0x97edd871 // .quad -7499099821171918250 + WORD $0xe3cbb5ad; WORD $0x97758bf0 // .quad -7532960934977096275 + WORD $0x43d0c8ec; WORD $0xbde94e8e // .quad -4762188758037509908 + WORD $0x1cbea318; WORD $0x3d52eeed // .quad 4418856886560793368 + WORD $0xd4c4fb27; WORD $0xed63a231 // .quad -1341049929119499481 + WORD $0x63ee4bde; WORD $0x4ca7aaa8 // .quad 5523571108200991710 + WORD $0x24fb1cf8; WORD $0x945e455f // .quad -7755685233340769032 + WORD $0x3e74ef6b; WORD $0x8fe8caa9 // .quad -8076983103442849941 + WORD $0xee39e436; WORD $0xb975d6b6 // .quad -5082920523248573386 + WORD $0x8e122b45; WORD $0xb3e2fd53 // .quad -5484542860876174523 + WORD $0xa9c85d44; WORD $0xe7d34c64 // .quad -1741964635633328828 + WORD $0x7196b617; WORD $0x60dbbca8 // .quad 6979379479186945559 + WORD $0xea1d3a4a; WORD $0x90e40fbe // .quad -8006256924911912374 + WORD $0x46fe31ce; WORD $0xbc8955e9 // .quad -4861259862362934834 + WORD $0xa4a488dd; WORD $0xb51d13ae // .quad -5396135137712502563 + WORD $0x98bdbe42; WORD $0x6babab63 // .quad 7758483227328495170 + WORD $0x4dcdab14; WORD $0xe264589a // .quad -2133482903713240300 + WORD $0x7eed2dd2; WORD $0xc696963c // .quad -4136954021121544750 + WORD $0x70a08aec; WORD $0x8d7eb760 // .quad -8250955842461857044 + WORD $0xcf543ca3; WORD $0xfc1e1de5 // .quad -279753253987271517 + WORD $0x8cc8ada8; WORD $0xb0de6538 // .quad -5702008784649933400 + WORD $0x43294bcc; WORD $0x3b25a55f // .quad 4261994450943298508 + WORD $0xaffad912; WORD $0xdd15fe86 // .quad -2515824962385028846 + WORD $0x13f39ebf; WORD $0x49ef0eb7 // .quad 5327493063679123135 + WORD $0x2dfcc7ab; WORD $0x8a2dbf14 // .quad -8489919629131724885 + WORD $0x6c784338; WORD $0x6e356932 // .quad 7941369183226839864 + WORD $0x397bf996; WORD $0xacb92ed9 // .quad -6000713517987268202 + WORD $0x07965405; WORD $0x49c2c37f // .quad 5315025460606161925 + WORD $0x87daf7fb; WORD $0xd7e77a8f // .quad -2889205879056697349 + WORD $0xc97be907; WORD $0xdc33745e // .quad -2579590211097073401 + WORD $0xb4e8dafd; WORD $0x86f0ac99 // .quad -8723282702051517699 + WORD $0x3ded71a4; WORD $0x69a028bb // .quad 7611128154919104932 + WORD $0x222311bc; WORD $0xa8acd7c0 // .quad -6292417359137009220 + WORD $0x0d68ce0d; WORD $0xc40832ea // .quad -4321147861633282547 + WORD $0x2aabd62b; WORD $0xd2d80db0 // .quad -3253835680493873621 + WORD $0x90c30191; WORD $0xf50a3fa4 // .quad -789748808614215279 + WORD $0x1aab65db; WORD $0x83c7088e // .quad -8951176327949752869 + WORD $0xda79e0fb; WORD $0x792667c6 // .quad 8729779031470891259 + WORD $0xa1563f52; WORD $0xa4b8cab1 // .quad -6577284391509803182 + WORD $0x91185939; WORD $0x577001b8 // .quad 6300537770911226169 + WORD $0x09abcf26; WORD $0xcde6fd5e // .quad -3609919470959866074 + WORD $0xb55e6f87; WORD $0xed4c0226 // .quad -1347699823215743097 + WORD $0xc60b6178; WORD $0x80b05e5a // .quad -9173728696990998152 + WORD $0x315b05b5; WORD $0x544f8158 // .quad 6075216638131242421 + WORD $0x778e39d6; WORD $0xa0dc75f1 // .quad -6855474852811359786 + WORD $0x3db1c722; WORD $0x696361ae // .quad 7594020797664053026 + WORD $0xd571c84c; WORD $0xc913936d // .quad -3957657547586811828 + WORD $0xcd1e38ea; WORD $0x03bc3a19 // .quad 269153960225290474 + WORD $0x4ace3a5f; WORD $0xfb587849 // .quad -335385916056126881 + WORD $0x4065c724; WORD $0x04ab48a0 // .quad 336442450281613092 + WORD $0xcec0e47b; WORD $0x9d174b2d // .quad -7127145225176161157 + WORD $0x283f9c77; WORD $0x62eb0d64 // .quad 7127805559067090039 + WORD $0x42711d9a; WORD $0xc45d1df9 // .quad -4297245513042813542 + WORD $0x324f8395; WORD $0x3ba5d0bd // .quad 4298070930406474645 + WORD $0x930d6500; WORD $0xf5746577 // .quad -759870872876129024 + WORD $0x7ee3647a; WORD $0xca8f44ec // .quad -3850783373846682502 + WORD $0xbbe85f20; WORD $0x9968bf6a // .quad -7392448323188662496 + WORD $0xcf4e1ecc; WORD $0x7e998b13 // .quad 9122475437414293196 + WORD $0x6ae276e8; WORD $0xbfc2ef45 // .quad -4628874385558440216 + WORD $0xc321a67f; WORD $0x9e3fedd8 // .quad -7043649776941685121 + WORD $0xc59b14a2; WORD $0xefb3ab16 // .quad -1174406963520662366 + WORD $0xf3ea101f; WORD $0xc5cfe94e // .quad -4192876202749718497 + WORD $0x3b80ece5; WORD $0x95d04aee // .quad -7651533379841495835 + WORD $0x58724a13; WORD $0xbba1f1d1 // .quad -4926390635932268013 + WORD $0xca61281f; WORD $0xbb445da9 // .quad -4952730706374481889 + WORD $0xae8edc98; WORD $0x2a8a6e45 // .quad 3065383741939440792 + WORD $0x3cf97226; WORD $0xea157514 // .quad -1579227364540714458 + WORD $0x1a3293be; WORD $0xf52d09d7 // .quad -779956341003086914 + WORD $0xa61be758; WORD $0x924d692c // .quad -7904546130479028392 + WORD $0x705f9c57; WORD $0x593c2626 // .quad 6430056314514152535 + WORD $0xcfa2e12e; WORD $0xb6e0c377 // .quad -5268996644671397586 + WORD $0x0c77836d; WORD $0x6f8b2fb0 // .quad 8037570393142690669 + WORD $0xc38b997a; WORD $0xe498f455 // .quad -1974559787411859078 + WORD $0x0f956448; WORD $0x0b6dfb9c // .quad 823590954573587528 + WORD $0x9a373fec; WORD $0x8edf98b5 // .quad -8151628894773493780 + WORD $0x89bd5ead; WORD $0x4724bd41 // .quad 5126430365035880109 + WORD $0x00c50fe7; WORD $0xb2977ee3 // .quad -5577850100039479321 + WORD $0xec2cb658; WORD $0x58edec91 // .quad 6408037956294850136 + WORD $0xc0f653e1; WORD $0xdf3d5e9b // .quad -2360626606621961247 + WORD $0x6737e3ee; WORD $0x2f2967b6 // .quad 3398361426941174766 + WORD $0x5899f46c; WORD $0x8b865b21 // .quad -8392920656779807636 + WORD $0x0082ee75; WORD $0xbd79e0d2 // .quad -4793553135802847627 + WORD $0xaec07187; WORD $0xae67f1e9 // .quad -5879464802547371641 + WORD $0x80a3aa12; WORD $0xecd85906 // .quad -1380255401326171630 + WORD $0x1a708de9; WORD $0xda01ee64 // .quad -2737644984756826647 + WORD $0x20cc9496; WORD $0xe80e6f48 // .quad -1725319251657714538 + WORD $0x908658b2; WORD $0x884134fe // .quad -8628557143114098510 + WORD $0x147fdcde; WORD $0x3109058d // .quad 3533361486141316318 + WORD $0x34a7eede; WORD $0xaa51823e // .quad -6174010410465235234 + WORD $0x599fd416; WORD $0xbd4b46f0 // .quad -4806670179178130410 + WORD $0xc1d1ea96; WORD $0xd4e5e2cd // .quad -3105826994654156138 + WORD $0x7007c91b; WORD $0x6c9e18ac // .quad 7826720331309500699 + WORD $0x9923329e; WORD $0x850fadc0 // .quad -8858670899299929442 + WORD $0xc604ddb1; WORD $0x03e2cf6b // .quad 280014188641050033 + WORD $0xbf6bff45; WORD $0xa6539930 // .quad -6461652605697523899 + WORD $0xb786151d; WORD $0x84db8346 // .quad -8873354301053463267 + WORD $0xef46ff16; WORD $0xcfe87f7c // .quad -3465379738694516970 + WORD $0x65679a64; WORD $0xe6126418 // .quad -1868320839462053276 + WORD $0x158c5f6e; WORD $0x81f14fae // .quad -9083391364325154962 + WORD $0x3f60c07f; WORD $0x4fcb7e8f // .quad 5749828502977298559 + WORD $0x9aef7749; WORD $0xa26da399 // .quad -6742553186979055799 + WORD $0x0f38f09e; WORD $0xe3be5e33 // .quad -2036086408133152610 + WORD $0x01ab551c; WORD $0xcb090c80 // .quad -3816505465296431844 + WORD $0xd3072cc6; WORD $0x5cadf5bf // .quad 6678264026688335046 + WORD $0x02162a63; WORD $0xfdcb4fa0 // .quad -158945813193151901 + WORD $0xc7c8f7f7; WORD $0x73d9732f // .quad 8347830033360418807 + WORD $0x014dda7e; WORD $0x9e9f11c4 // .quad -7016870160886801794 + WORD $0xdcdd9afb; WORD $0x2867e7fd // .quad 2911550761636567803 + WORD $0x01a1511d; WORD $0xc646d635 // .quad -4159401682681114339 + WORD $0x541501b9; WORD $0xb281e1fd // .quad -5583933584809066055 + WORD $0x4209a565; WORD $0xf7d88bc2 // .quad -587566084924005019 + WORD $0xa91a4227; WORD $0x1f225a7c // .quad 2243455055843443239 + WORD $0x6946075f; WORD $0x9ae75759 // .quad -7284757830718584993 + WORD $0xe9b06959; WORD $0x3375788d // .quad 3708002419115845977 + WORD $0xc3978937; WORD $0xc1a12d2f // .quad -4494261269970843337 + WORD $0x641c83af; WORD $0x0052d6b1 // .quad 23317005467419567 + WORD $0xb47d6b84; WORD $0xf209787b // .quad -1006140569036166268 + WORD $0xbd23a49b; WORD $0xc0678c5d // .quad -4582539761593113445 + WORD $0x50ce6332; WORD $0x9745eb4d // .quad -7546366883288685774 + WORD $0x963646e1; WORD $0xf840b7ba // .quad -558244341782001951 + WORD $0xa501fbff; WORD $0xbd176620 // .quad -4821272585683469313 + WORD $0x3bc3d899; WORD $0xb650e5a9 // .quad -5309491445654890343 + WORD $0xce427aff; WORD $0xec5d3fa8 // .quad -1414904713676948737 + WORD $0x8ab4cebf; WORD $0xa3e51f13 // .quad -6636864307068612929 + WORD $0x80e98cdf; WORD $0x93ba47c9 // .quad -7801844473689174817 + WORD $0x36b10138; WORD $0xc66f336c // .quad -4148040191917883080 + WORD $0xe123f017; WORD $0xb8a8d9bb // .quad -5140619573684080617 + WORD $0x445d4185; WORD $0xb80b0047 // .quad -5185050239897353851 + WORD $0xd96cec1d; WORD $0xe6d3102a // .quad -1814088448677712867 + WORD $0x157491e6; WORD $0xa60dc059 // .quad -6481312799871692314 + WORD $0xc7e41392; WORD $0x9043ea1a // .quad -8051334308064652398 + WORD $0xad68db30; WORD $0x87c89837 // .quad -8662506518347195600 + WORD $0x79dd1877; WORD $0xb454e4a1 // .quad -5452481866653427593 + WORD $0x98c311fc; WORD $0x29babe45 // .quad 3006924907348169212 + WORD $0xd8545e94; WORD $0xe16a1dc9 // .quad -2203916314889396588 + WORD $0xfef3d67b; WORD $0xf4296dd6 // .quad -853029884242176389 + WORD $0x2734bb1d; WORD $0x8ce2529e // .quad -8294976724446954723 + WORD $0x5f58660d; WORD $0x1899e4a6 // .quad 1772699331562333709 + WORD $0xb101e9e4; WORD $0xb01ae745 // .quad -5757034887131305500 + WORD $0xf72e7f90; WORD $0x5ec05dcf // .quad 6827560182880305040 + WORD $0x1d42645d; WORD $0xdc21a117 // .quad -2584607590486743971 + WORD $0xf4fa1f74; WORD $0x76707543 // .quad 8534450228600381300 + WORD $0x72497eba; WORD $0x899504ae // .quad -8532908771695296838 + WORD $0x791c53a9; WORD $0x6a06494a // .quad 7639874402088932265 + WORD $0x0edbde69; WORD $0xabfa45da // .quad -6054449946191733143 + WORD $0x17636893; WORD $0x0487db9d // .quad 326470965756389523 + WORD $0x9292d603; WORD $0xd6f8d750 // .quad -2956376414312278525 + WORD $0x5d3c42b7; WORD $0x45a9d284 // .quad 5019774725622874807 + WORD $0x5b9bc5c2; WORD $0x865b8692 // .quad -8765264286586255934 + WORD $0xba45a9b3; WORD $0x0b8a2392 // .quad 831516194300602803 + WORD $0xf282b732; WORD $0xa7f26836 // .quad -6344894339805432014 + WORD $0x68d7141f; WORD $0x8e6cac77 // .quad -8183976793979022305 + WORD $0xaf2364ff; WORD $0xd1ef0244 // .quad -3319431906329402113 + WORD $0x430cd927; WORD $0x3207d795 // .quad 3605087062808385831 + WORD $0xed761f1f; WORD $0x8335616a // .quad -8992173969096958177 + WORD $0x49e807b9; WORD $0x7f44e6bd // .quad 9170708441896323001 + WORD $0xa8d3a6e7; WORD $0xa402b9c5 // .quad -6628531442943809817 + WORD $0x9c6209a7; WORD $0x5f16206c // .quad 6851699533943015847 + WORD $0x130890a1; WORD $0xcd036837 // .quad -3673978285252374367 + WORD $0xc37a8c10; WORD $0x36dba887 // .quad 3952938399001381904 + WORD $0x6be55a64; WORD $0x80222122 // .quad -9213765455923815836 + WORD $0xda2c978a; WORD $0xc2494954 // .quad -4446942528265218166 + WORD $0x06deb0fd; WORD $0xa02aa96b // .quad -6905520801477381891 + WORD $0x10b7bd6d; WORD $0xf2db9baa // .quad -946992141904134803 + WORD $0xc8965d3d; WORD $0xc83553c5 // .quad -4020214983419339459 + WORD $0x94e5acc8; WORD $0x6f928294 // .quad 8039631859474607304 + WORD $0x3abbf48c; WORD $0xfa42a8b7 // .quad -413582710846786420 + WORD $0xba1f17fa; WORD $0xcb772339 // .quad -3785518230938904582 + WORD $0x84b578d7; WORD $0x9c69a972 // .quad -7176018221920323369 + WORD $0x14536efc; WORD $0xff2a7604 // .quad -60105885123121412 + WORD $0x25e2d70d; WORD $0xc38413cf // .quad -4358336758973016307 + WORD $0x19684abb; WORD $0xfef51385 // .quad -75132356403901765 + WORD $0xef5b8cd1; WORD $0xf46518c2 // .quad -836234930288882479 + WORD $0x5fc25d6a; WORD $0x7eb25866 // .quad 9129456591349898602 + WORD $0xd5993802; WORD $0x98bf2f79 // .quad -7440175859071633406 + WORD $0xfbd97a62; WORD $0xef2f773f // .quad -1211618658047395230 + WORD $0x4aff8603; WORD $0xbeeefb58 // .quad -4688533805412153853 + WORD $0xfacfd8fb; WORD $0xaafb550f // .quad -6126209340986631941 + WORD $0x5dbf6784; WORD $0xeeaaba2e // .quad -1248981238337804412 + WORD $0xf983cf39; WORD $0x95ba2a53 // .quad -7657761676233289927 + WORD $0xfa97a0b2; WORD $0x952ab45c // .quad -7698142301602209614 + WORD $0x7bf26184; WORD $0xdd945a74 // .quad -2480258038432112252 + WORD $0x393d88df; WORD $0xba756174 // .quad -5010991858575374113 + WORD $0x9aeef9e5; WORD $0x94f97111 // .quad -7712008566467528219 + WORD $0x478ceb17; WORD $0xe912b9d1 // .quad -1652053804791829737 + WORD $0x01aab85e; WORD $0x7a37cd56 // .quad 8806733365625141342 + WORD $0xccb812ee; WORD $0x91abb422 // .quad -7950062655635975442 + WORD $0xc10ab33b; WORD $0xac62e055 // .quad -6025006692552756421 + WORD $0x7fe617aa; WORD $0xb616a12b // .quad -5325892301117581398 + WORD $0x314d600a; WORD $0x577b986b // .quad 6303799689591218186 + WORD $0x5fdf9d94; WORD $0xe39c4976 // .quad -2045679357969588844 + WORD $0xfda0b80c; WORD $0xed5a7e85 // .quad -1343622424865753076 + WORD $0xfbebc27d; WORD $0x8e41ade9 // .quad -8196078626372074883 + WORD $0xbe847308; WORD $0x14588f13 // .quad 1466078993672598280 + WORD $0x7ae6b31c; WORD $0xb1d21964 // .quad -5633412264537705700 + WORD $0xae258fc9; WORD $0x596eb2d8 // .quad 6444284760518135753 + WORD $0x99a05fe3; WORD $0xde469fbd // .quad -2430079312244744221 + WORD $0xd9aef3bc; WORD $0x6fca5f8e // .quad 8055355950647669692 + WORD $0x80043bee; WORD $0x8aec23d6 // .quad -8436328597794046994 + WORD $0x480d5855; WORD $0x25de7bb9 // .quad 2728754459941099605 + WORD $0x20054ae9; WORD $0xada72ccc // .quad -5933724728815170839 + WORD $0x9a10ae6b; WORD $0xaf561aa7 // .quad -5812428961928401301 + WORD $0x28069da4; WORD $0xd910f7ff // .quad -2805469892591575644 + WORD $0x8094da05; WORD $0x1b2ba151 // .quad 1957835834444274181 + WORD $0x79042286; WORD $0x87aa9aff // .quad -8670947710510816634 + WORD $0xf05d0843; WORD $0x90fb44d2 // .quad -7999724640327104445 + WORD $0x57452b28; WORD $0xa99541bf // .quad -6226998619711132888 + WORD $0xac744a54; WORD $0x353a1607 // .quad 3835402254873283156 + WORD $0x2d1675f2; WORD $0xd3fa922f // .quad -3172062256211528206 + WORD $0x97915ce9; WORD $0x42889b89 // .quad 4794252818591603945 + WORD $0x7c2e09b7; WORD $0x847c9b5d // .quad -8900067937773286985 + WORD $0xfebada12; WORD $0x69956135 // .quad 7608094030047140370 + WORD $0xdb398c25; WORD $0xa59bc234 // .quad -6513398903789220827 + WORD $0x7e699096; WORD $0x43fab983 // .quad 4898431519131537558 + WORD $0x1207ef2e; WORD $0xcf02b2c2 // .quad -3530062611309138130 + WORD $0x5e03f4bc; WORD $0x94f967e4 // .quad -7712018656367741764 + WORD $0x4b44f57d; WORD $0x8161afb9 // .quad -9123818159709293187 + WORD $0xbac278f6; WORD $0x1d1be0ee // .quad 2097517367411243254 + WORD $0x9e1632dc; WORD $0xa1ba1ba7 // .quad -6793086681209228580 + WORD $0x69731733; WORD $0x6462d92a // .quad 7233582727691441971 + WORD $0x859bbf93; WORD $0xca28a291 // .quad -3879672333084147821 + WORD $0x03cfdcff; WORD $0x7d7b8f75 // .quad 9041978409614302463 + WORD $0xe702af78; WORD $0xfcb2cb35 // .quad -237904397927796872 + WORD $0x44c3d43f; WORD $0x5cda7352 // .quad 6690786993590490175 + WORD $0xb061adab; WORD $0x9defbf01 // .quad -7066219276345954901 + WORD $0x6afa64a8; WORD $0x3a088813 // .quad 4181741870994056360 + WORD $0x1c7a1916; WORD $0xc56baec2 // .quad -4221088077005055722 + WORD $0x45b8fdd1; WORD $0x088aaa18 // .quad 615491320315182545 + WORD $0xa3989f5b; WORD $0xf6c69a72 // .quad -664674077828931749 + WORD $0x57273d46; WORD $0x8aad549e // .quad -8454007886460797626 + WORD $0xa63f6399; WORD $0x9a3c2087 // .quad -7332950326284164199 + WORD $0xf678864c; WORD $0x36ac54e2 // .quad 3939617107816777292 + WORD $0x8fcf3c7f; WORD $0xc0cb28a9 // .quad -4554501889427817345 + WORD $0xb416a7de; WORD $0x84576a1b // .quad -8910536670511192098 + WORD $0xf3c30b9f; WORD $0xf0fdf2d3 // .quad -1081441343357383777 + WORD $0xa11c51d6; WORD $0x656d44a2 // .quad 7308573235570561494 + WORD $0x7859e743; WORD $0x969eb7c4 // .quad -7593429867239446717 + WORD $0xa4b1b326; WORD $0x9f644ae5 // .quad -6961356773836868826 + WORD $0x96706114; WORD $0xbc4665b5 // .quad -4880101315621920492 + WORD $0x0dde1fef; WORD $0x873d5d9f // .quad -8701695967296086033 + WORD $0xfc0c7959; WORD $0xeb57ff22 // .quad -1488440626100012711 + WORD $0xd155a7eb; WORD $0xa90cb506 // .quad -6265433940692719637 + WORD $0xdd87cbd8; WORD $0x9316ff75 // .quad -7847804418953589800 + WORD $0x42d588f3; WORD $0x09a7f124 // .quad 695789805494438131 + WORD $0x54e9bece; WORD $0xb7dcbf53 // .quad -5198069505264599346 + WORD $0x538aeb30; WORD $0x0c11ed6d // .quad 869737256868047664 + WORD $0x2a242e81; WORD $0xe5d3ef28 // .quad -1885900863153361279 + WORD $0xa86da5fb; WORD $0x8f1668c8 // .quad -8136200465769716229 + WORD $0x1a569d10; WORD $0x8fa47579 // .quad -8096217067111932656 + WORD $0x694487bd; WORD $0xf96e017d // .quad -473439272678684739 + WORD $0x60ec4455; WORD $0xb38d92d7 // .quad -5508585315462527915 + WORD $0xc395a9ad; WORD $0x37c981dc // .quad 4019886927579031981 + WORD $0x3927556a; WORD $0xe070f78d // .quad -2274045625900771990 + WORD $0xf47b1418; WORD $0x85bbe253 // .quad -8810199395808373736 + WORD $0x43b89562; WORD $0x8c469ab8 // .quad -8338807543829064350 + WORD $0x78ccec8f; WORD $0x93956d74 // .quad -7812217631593927537 + WORD $0x54a6babb; WORD $0xaf584166 // .quad -5811823411358942533 + WORD $0x970027b3; WORD $0x387ac8d1 // .quad 4069786015789754291 + WORD $0xe9d0696a; WORD $0xdb2e51bf // .quad -2653093245771290262 + WORD $0xfcc0319f; WORD $0x06997b05 // .quad 475546501309804959 + WORD $0xf22241e2; WORD $0x88fcf317 // .quad -8575712306248138270 + WORD $0xbdf81f04; WORD $0x441fece3 // .quad 4908902581746016004 + WORD $0xeeaad25a; WORD $0xab3c2fdd // .quad -6107954364382784934 + WORD $0xad7626c4; WORD $0xd527e81c // .quad -3087243809672255804 + WORD $0x6a5586f1; WORD $0xd60b3bd5 // .quad -3023256937051093263 + WORD $0xd8d3b075; WORD $0x8a71e223 // .quad -8470740780517707659 + WORD $0x62757456; WORD $0x85c70565 // .quad -8807064613298015146 + WORD $0x67844e4a; WORD $0xf6872d56 // .quad -682526969396179382 + WORD $0xbb12d16c; WORD $0xa738c6be // .quad -6397144748195131028 + WORD $0x016561dc; WORD $0xb428f8ac // .quad -5464844730172612132 + WORD $0x69d785c7; WORD $0xd106f86e // .quad -3384744916816525881 + WORD $0x01beba53; WORD $0xe13336d7 // .quad -2219369894288377261 + WORD $0x0226b39c; WORD $0x82a45b45 // .quad -9032994600651410532 + WORD $0x61173474; WORD $0xecc00246 // .quad -1387106183930235788 + WORD $0x42b06084; WORD $0xa34d7216 // .quad -6679557232386875260 + WORD $0xf95d0191; WORD $0x27f002d7 // .quad 2877803288514593169 + WORD $0xd35c78a5; WORD $0xcc20ce9b // .quad -3737760522056206171 + WORD $0xf7b441f5; WORD $0x31ec038d // .quad 3597254110643241461 + WORD $0xc83396ce; WORD $0xff290242 // .quad -60514634142869810 + WORD $0x75a15272; WORD $0x7e670471 // .quad 9108253656731439730 + WORD $0xbd203e41; WORD $0x9f79a169 // .quad -6955350673980375487 + WORD $0xe984d387; WORD $0x0f0062c6 // .quad 1080972517029761927 + WORD $0x2c684dd1; WORD $0xc75809c4 // .quad -4082502324048081455 + WORD $0xa3e60869; WORD $0x52c07b78 // .quad 5962901664714590313 + WORD $0x37826145; WORD $0xf92e0c35 // .quad -491441886632713915 + WORD $0xccdf8a83; WORD $0xa7709a56 // .quad -6381430974388925821 + WORD $0x42b17ccb; WORD $0x9bbcc7a1 // .quad -7224680206786528053 + WORD $0x400bb692; WORD $0x88a66076 // .quad -8600080377420466542 + WORD $0x935ddbfe; WORD $0xc2abf989 // .quad -4419164240055772162 + WORD $0xd00ea436; WORD $0x6acff893 // .quad 7696643601933968438 + WORD $0xf83552fe; WORD $0xf356f7eb // .quad -912269281642327298 + WORD $0xc4124d44; WORD $0x0583f6b8 // .quad 397432465562684740 + WORD $0x7b2153de; WORD $0x98165af3 // .quad -7487697328667536418 + WORD $0x7a8b704b; WORD $0xc3727a33 // .quad -4363290727450709941 + WORD $0x59e9a8d6; WORD $0xbe1bf1b0 // .quad -4747935642407032618 + WORD $0x592e4c5d; WORD $0x744f18c0 // .quad 8380944645968776285 + WORD $0x7064130c; WORD $0xeda2ee1c // .quad -1323233534581402868 + WORD $0x6f79df74; WORD $0x1162def0 // .quad 1252808770606194548 + WORD $0xc63e8be7; WORD $0x9485d4d1 // .quad -7744549986754458649 + WORD $0x45ac2ba9; WORD $0x8addcb56 // .quad -8440366555225904215 + WORD $0x37ce2ee1; WORD $0xb9a74a06 // .quad -5069001465015685407 + WORD $0xd7173693; WORD $0x6d953e2b // .quad 7896285879677171347 + WORD $0xc5c1ba99; WORD $0xe8111c87 // .quad -1724565812842218855 + WORD $0xccdd0438; WORD $0xc8fa8db6 // .quad -3964700705685699528 + WORD $0xdb9914a0; WORD $0x910ab1d4 // .quad -7995382660667468640 + WORD $0x400a22a3; WORD $0x1d9c9892 // .quad 2133748077373825699 + WORD $0x127f59c8; WORD $0xb54d5e4a // .quad -5382542307406947896 + WORD $0xd00cab4c; WORD $0x2503beb6 // .quad 2667185096717282124 + WORD $0x971f303a; WORD $0xe2a0b5dc // .quad -2116491865831296966 + WORD $0x840fd61e; WORD $0x2e44ae64 // .quad 3333981370896602654 + WORD $0xde737e24; WORD $0x8da471a9 // .quad -8240336443785642460 + WORD $0xd289e5d3; WORD $0x5ceaecfe // .quad 6695424375237764563 + WORD $0x56105dad; WORD $0xb10d8e14 // .quad -5688734536304665171 + WORD $0x872c5f48; WORD $0x7425a83e // .quad 8369280469047205704 + WORD $0x6b947518; WORD $0xdd50f199 // .quad -2499232151953443560 + WORD $0x28f7771a; WORD $0xd12f124e // .quad -3373457468973156582 + WORD $0xe33cc92f; WORD $0x8a5296ff // .quad -8479549122611984081 + WORD $0xd99aaa70; WORD $0x82bd6b70 // .quad -9025939945749304720 + WORD $0xdc0bfb7b; WORD $0xace73cbf // .quad -5987750384837592197 + WORD $0x1001550c; WORD $0x636cc64d // .quad 7164319141522920716 + WORD $0xd30efa5a; WORD $0xd8210bef // .quad -2873001962619602342 + WORD $0x5401aa4f; WORD $0x3c47f7e0 // .quad 4343712908476262991 + WORD $0xe3e95c78; WORD $0x8714a775 // .quad -8713155254278333320 + WORD $0x34810a72; WORD $0x65acfaec // .quad 7326506586225052274 + WORD $0x5ce3b396; WORD $0xa8d9d153 // .quad -6279758049420528746 + WORD $0x41a14d0e; WORD $0x7f1839a7 // .quad 9158133232781315342 + WORD $0x341ca07c; WORD $0xd31045a8 // .quad -3238011543348273028 + WORD $0x1209a051; WORD $0x1ede4811 // .quad 2224294504121868369 + WORD $0x2091e44d; WORD $0x83ea2b89 // .quad -8941286242233752499 + WORD $0xab460433; WORD $0x934aed0a // .quad -7833187971778608077 + WORD $0x68b65d60; WORD $0xa4e4b66b // .quad -6564921784364802720 + WORD $0x56178540; WORD $0xf81da84d // .quad -568112927868484288 + WORD $0x42e3f4b9; WORD $0xce1de406 // .quad -3594466212028615495 + WORD $0xab9d668f; WORD $0x36251260 // .quad 3901544858591782543 + WORD $0xe9ce78f3; WORD $0x80d2ae83 // .quad -9164070410158966541 + WORD $0x6b42601a; WORD $0xc1d72b7c // .quad -4479063491021217766 + WORD $0xe4421730; WORD $0xa1075a24 // .quad -6843401994271320272 + WORD $0x8612f820; WORD $0xb24cf65b // .quad -5598829363776522208 + WORD $0x1d529cfc; WORD $0xc94930ae // .quad -3942566474411762436 + WORD $0x6797b628; WORD $0xdee033f2 // .quad -2386850686293264856 + WORD $0xa4a7443c; WORD $0xfb9b7cd9 // .quad -316522074587315140 + WORD $0x017da3b2; WORD $0x169840ef // .quad 1628122660560806834 + WORD $0x06e88aa5; WORD $0x9d412e08 // .quad -7115355324258153819 + WORD $0x60ee864f; WORD $0x8e1f2895 // .quad -8205795374004271537 + WORD $0x08a2ad4e; WORD $0xc491798a // .quad -4282508136895304370 + WORD $0xb92a27e3; WORD $0xf1a6f2ba // .quad -1033872180650563613 + WORD $0x8acb58a2; WORD $0xf5b5d7ec // .quad -741449152691742558 + WORD $0x6774b1dc; WORD $0xae10af69 // .quad -5904026244240592420 + WORD $0xd6bf1765; WORD $0x9991a6f3 // .quad -7380934748073420955 + WORD $0xe0a8ef2a; WORD $0xacca6da1 // .quad -5995859411864064214 + WORD $0xcc6edd3f; WORD $0xbff610b0 // .quad -4614482416664388289 + WORD $0x58d32af4; WORD $0x17fd090a // .quad 1728547772024695540 + WORD $0xff8a948e; WORD $0xeff394dc // .quad -1156417002403097458 + WORD $0xef07f5b1; WORD $0xddfc4b4c // .quad -2451001303396518479 + WORD $0x1fb69cd9; WORD $0x95f83d0a // .quad -7640289654143017767 + WORD $0x1564f98f; WORD $0x4abdaf10 // .quad 5385653213018257807 + WORD $0xa7a4440f; WORD $0xbb764c4c // .quad -4938676049251384305 + WORD $0x1abe37f2; WORD $0x9d6d1ad4 // .quad -7102991539009341454 + WORD $0xd18d5513; WORD $0xea53df5f // .quad -1561659043136842477 + WORD $0x216dc5ee; WORD $0x84c86189 // .quad -8878739423761676818 + WORD $0xe2f8552c; WORD $0x92746b9b // .quad -7893565929601608404 + WORD $0xb4e49bb5; WORD $0x32fd3cf5 // .quad 3674159897003727797 + WORD $0xdbb66a77; WORD $0xb7118682 // .quad -5255271393574622601 + WORD $0x221dc2a2; WORD $0x3fbc8c33 // .quad 4592699871254659746 + WORD $0x92a40515; WORD $0xe4d5e823 // .quad -1957403223540890347 + WORD $0xeaa5334b; WORD $0x0fabaf3f // .quad 1129188820640936779 + WORD $0x3ba6832d; WORD $0x8f05b116 // .quad -8140906042354138323 + WORD $0xf2a7400f; WORD $0x29cb4d87 // .quad 3011586022114279439 + WORD $0xca9023f8; WORD $0xb2c71d5b // .quad -5564446534515285000 + WORD $0xef511013; WORD $0x743e20e9 // .quad 8376168546070237203 + WORD $0xbd342cf6; WORD $0xdf78e4b2 // .quad -2343872149716718346 + WORD $0x6b255417; WORD $0x914da924 // .quad -7976533391121755113 + WORD $0xb6409c1a; WORD $0x8bab8eef // .quad -8382449121214030822 + WORD $0xc2f7548f; WORD $0x1ad089b6 // .quad 1932195658189984911 + WORD $0xa3d0c320; WORD $0xae9672ab // .quad -5866375383090150624 + WORD $0x73b529b2; WORD $0xa184ac24 // .quad -6808127464117294670 + WORD $0x8cc4f3e8; WORD $0xda3c0f56 // .quad -2721283210435300376 + WORD $0x90a2741f; WORD $0xc9e5d72d // .quad -3898473311719230433 + WORD $0x17fb1871; WORD $0x88658996 // .quad -8618331034163144591 + WORD $0x7a658893; WORD $0x7e2fa67c // .quad 9092669226243950739 + WORD $0x9df9de8d; WORD $0xaa7eebfb // .quad -6161227774276542835 + WORD $0x98feeab8; WORD $0xddbb901b // .quad -2469221522477225288 + WORD $0x85785631; WORD $0xd51ea6fa // .quad -3089848699418290639 + WORD $0x7f3ea566; WORD $0x552a7422 // .quad 6136845133758244198 + WORD $0x936b35de; WORD $0x8533285c // .quad -8848684464777513506 + WORD $0x8f872760; WORD $0xd53a8895 // .quad -3082000819042179232 + WORD $0xb8460356; WORD $0xa67ff273 // .quad -6449169562544503978 + WORD $0xf368f138; WORD $0x8a892aba // .quad -8464187042230111944 + WORD $0xa657842c; WORD $0xd01fef10 // .quad -3449775934753242068 + WORD $0xb0432d86; WORD $0x2d2b7569 // .quad 3254824252494523782 + WORD $0x67f6b29b; WORD $0x8213f56a // .quad -9073638986861858149 + WORD $0x0e29fc74; WORD $0x9c3b2962 // .quad -7189106879045698444 + WORD $0x01f45f42; WORD $0xa298f2c5 // .quad -6730362715149934782 + WORD $0x91b47b90; WORD $0x8349f3ba // .quad -8986383598807123056 + WORD $0x42717713; WORD $0xcb3f2f76 // .quad -3801267375510030573 + WORD $0x36219a74; WORD $0x241c70a9 // .quad 2602078556773259892 + WORD $0xd30dd4d7; WORD $0xfe0efb53 // .quad -139898200960150313 + WORD $0x83aa0111; WORD $0xed238cd3 // .quad -1359087822460813039 + WORD $0x63e8a506; WORD $0x9ec95d14 // .quad -7004965403241175802 + WORD $0x324a40ab; WORD $0xf4363804 // .quad -849429889038008149 + WORD $0x7ce2ce48; WORD $0xc67bb459 // .quad -4144520735624081848 + WORD $0x3edcd0d6; WORD $0xb143c605 // .quad -5673473379724898090 + WORD $0xdc1b81da; WORD $0xf81aa16f // .quad -568964901102714406 + WORD $0x8e94050b; WORD $0xdd94b786 // .quad -2480155706228734709 + WORD $0xe9913128; WORD $0x9b10a4e5 // .quad -7273132090830278360 + WORD $0x191c8327; WORD $0xca7cf2b4 // .quad -3855940325606653145 + WORD $0x63f57d72; WORD $0xc1d4ce1f // .quad -4479729095110460046 + WORD $0x1f63a3f1; WORD $0xfd1c2f61 // .quad -208239388580928527 + WORD $0x3cf2dccf; WORD $0xf24a01a7 // .quad -987975350460687153 + WORD $0x673c8ced; WORD $0xbc633b39 // .quad -4871985254153548563 + WORD $0x8617ca01; WORD $0x976e4108 // .quad -7535013621679011327 + WORD $0xe085d814; WORD $0xd5be0503 // .quad -3044990783845967852 + WORD $0xa79dbc82; WORD $0xbd49d14a // .quad -4807081008671376254 + WORD $0xd8a74e19; WORD $0x4b2d8644 // .quad 5417133557047315993 + WORD $0x51852ba2; WORD $0xec9c459d // .quad -1397165242411832414 + WORD $0x0ed1219f; WORD $0xddf8e7d6 // .quad -2451955090545630817 + WORD $0x52f33b45; WORD $0x93e1ab82 // .quad -7790757304148477115 + WORD $0xc942b504; WORD $0xcabb90e5 // .quad -3838314940804713212 + WORD $0xe7b00a17; WORD $0xb8da1662 // .quad -5126760611758208489 + WORD $0x3b936244; WORD $0x3d6a751f // .quad 4425478360848884292 + WORD $0xa19c0c9d; WORD $0xe7109bfb // .quad -1796764746270372707 + WORD $0x0a783ad5; WORD $0x0cc51267 // .quad 920161932633717461 + WORD $0x450187e2; WORD $0x906a617d // .quad -8040506994060064798 + WORD $0x668b24c6; WORD $0x27fb2b80 // .quad 2880944217109767366 + WORD $0x9641e9da; WORD $0xb484f9dc // .quad -5438947724147693094 + WORD $0x802dedf7; WORD $0xb1f9f660 // .quad -5622191765467566601 + WORD $0xbbd26451; WORD $0xe1a63853 // .quad -2186998636757228463 + WORD $0xa0396974; WORD $0x5e7873f8 // .quad 6807318348447705460 + WORD $0x55637eb2; WORD $0x8d07e334 // .quad -8284403175614349646 + WORD $0x6423e1e9; WORD $0xdb0b487b // .quad -2662955059861265943 + WORD $0x6abc5e5f; WORD $0xb049dc01 // .quad -5743817951090549153 + WORD $0x3d2cda63; WORD $0x91ce1a9a // .quad -7940379843253970333 + WORD $0xc56b75f7; WORD $0xdc5c5301 // .quad -2568086420435798537 + WORD $0xcc7810fc; WORD $0x7641a140 // .quad 8521269269642088700 + WORD $0x1b6329ba; WORD $0x89b9b3e1 // .quad -8522583040413455942 + WORD $0x7fcb0a9e; WORD $0xa9e904c8 // .quad -6203421752542164322 + WORD $0x623bf429; WORD $0xac2820d9 // .quad -6041542782089432023 + WORD $0x9fbdcd45; WORD $0x546345fa // .quad 6080780864604458309 + WORD $0xbacaf133; WORD $0xd732290f // .quad -2940242459184402125 + WORD $0x47ad4096; WORD $0xa97c1779 // .quad -6234081974526590826 + WORD $0xd4bed6c0; WORD $0x867f59a9 // .quad -8755180564631333184 + WORD $0xcccc485e; WORD $0x49ed8eab // .quad 5327070802775656542 + WORD $0x49ee8c70; WORD $0xa81f3014 // .quad -6332289687361778576 + WORD $0xbfff5a75; WORD $0x5c68f256 // .quad 6658838503469570677 + WORD $0x5c6a2f8c; WORD $0xd226fc19 // .quad -3303676090774835316 + WORD $0x6fff3112; WORD $0x73832eec // .quad 8323548129336963346 + WORD $0xd9c25db7; WORD $0x83585d8f // .quad -8982326584375353929 + WORD $0xc5ff7eac; WORD $0xc831fd53 // .quad -4021154456019173716 + WORD $0xd032f525; WORD $0xa42e74f3 // .quad -6616222212041804507 + WORD $0xb77f5e56; WORD $0xba3e7ca8 // .quad -5026443070023967146 + WORD $0xc43fb26f; WORD $0xcd3a1230 // .quad -3658591746624867729 + WORD $0xe55f35ec; WORD $0x28ce1bd2 // .quad 2940318199324816876 + WORD $0x7aa7cf85; WORD $0x80444b5e // .quad -9204148869281624187 + WORD $0xcf5b81b4; WORD $0x7980d163 // .quad 8755227902219092404 + WORD $0x1951c366; WORD $0xa0555e36 // .quad -6893500068174642330 + WORD $0xc3326220; WORD $0xd7e105bc // .quad -2891023177508298208 + WORD $0x9fa63440; WORD $0xc86ab5c3 // .quad -4005189066790915008 + WORD $0xf3fefaa8; WORD $0x8dd9472b // .quad -8225464990312760664 + WORD $0x878fc150; WORD $0xfa856334 // .quad -394800315061255856 + WORD $0xf0feb952; WORD $0xb14f98f6 // .quad -5670145219463562926 + WORD $0xd4b9d8d2; WORD $0x9c935e00 // .quad -7164279224554366766 + WORD $0x569f33d4; WORD $0x6ed1bf9a // .quad 7985374283903742932 + WORD $0x09e84f07; WORD $0xc3b83581 // .quad -4343663012265570553 + WORD $0xec4700c9; WORD $0x0a862f80 // .quad 758345818024902857 + WORD $0x4c6262c8; WORD $0xf4a642e1 // .quad -817892746904575288 + WORD $0x2758c0fb; WORD $0xcd27bb61 // .quad -3663753745896259333 + WORD $0xcfbd7dbd; WORD $0x98e7e9cc // .quad -7428711994456441411 + WORD $0xb897789d; WORD $0x8038d51c // .quad -9207375118826243939 + WORD $0x03acdd2c; WORD $0xbf21e440 // .quad -4674203974643163860 + WORD $0xe6bd56c4; WORD $0xe0470a63 // .quad -2285846861678029116 + WORD $0x04981478; WORD $0xeeea5d50 // .quad -1231068949876566920 + WORD $0xe06cac75; WORD $0x1858ccfc // .quad 1754377441329851509 + WORD $0x02df0ccb; WORD $0x95527a52 // .quad -7686947121313936181 + WORD $0x0c43ebc9; WORD $0x0f37801e // .quad 1096485900831157193 + WORD $0x8396cffd; WORD $0xbaa718e6 // .quad -4996997883215032323 + WORD $0x8f54e6bb; WORD $0xd3056025 // .quad -3241078642388441413 + WORD $0x247c83fd; WORD $0xe950df20 // .quad -1634561335591402499 + WORD $0xf32a206a; WORD $0x47c6b82e // .quad 5172023733869224042 + WORD $0x16cdd27e; WORD $0x91d28b74 // .quad -7939129862385708418 + WORD $0x57fa5442; WORD $0x4cdc331d // .quad 5538357842881958978 + WORD $0x1c81471d; WORD $0xb6472e51 // .quad -5312226309554747619 + WORD $0xadf8e953; WORD $0xe0133fe4 // .quad -2300424733252327085 + WORD $0x63a198e5; WORD $0xe3d8f9e5 // .quad -2028596868516046619 + WORD $0xd97723a7; WORD $0x58180fdd // .quad 6347841120289366951 + WORD $0x5e44ff8f; WORD $0x8e679c2f // .quad -8185402070463610993 + WORD $0xa7ea7649; WORD $0x570f09ea // .quad 6273243709394548297 + WORD $0x35d63f73; WORD $0xb201833b // .quad -5620066569652125837 + WORD $0x51e513db; WORD $0x2cd2cc65 // .quad 3229868618315797467 + WORD $0x034bcf4f; WORD $0xde81e40a // .quad -2413397193637769393 + WORD $0xa65e58d2; WORD $0xf8077f7e // .quad -574350245532641070 + WORD $0x420f6191; WORD $0x8b112e86 // .quad -8425902273664687727 + WORD $0x27faf783; WORD $0xfb04afaf // .quad -358968903457900669 + WORD $0xd29339f6; WORD $0xadd57a27 // .quad -5920691823653471754 + WORD $0xf1f9b564; WORD $0x79c5db9a // .quad 8774660907532399972 + WORD $0xc7380874; WORD $0xd94ad8b1 // .quad -2789178761139451788 + WORD $0xae7822bd; WORD $0x18375281 // .quad 1744954097560724157 + WORD $0x1c830548; WORD $0x87cec76f // .quad -8660765753353239224 + WORD $0x0d0b15b6; WORD $0x8f229391 // .quad -8132775725879323210 + WORD $0xe3a3c69a; WORD $0xa9c2794a // .quad -6214271173264161126 + WORD $0x504ddb23; WORD $0xb2eb3875 // .quad -5554283638921766109 + WORD $0x9c8cb841; WORD $0xd433179d // .quad -3156152948152813503 + WORD $0xa46151ec; WORD $0x5fa60692 // .quad 6892203506629956076 + WORD $0x81d7f328; WORD $0x849feec2 // .quad -8890124620236590296 + WORD $0xa6bcd334; WORD $0xdbc7c41b // .quad -2609901835997359308 + WORD $0x224deff3; WORD $0xa5c7ea73 // .quad -6500969756868349965 + WORD $0x906c0801; WORD $0x12b9b522 // .quad 1349308723430688769 + WORD $0xeae16bef; WORD $0xcf39e50f // .quad -3514526177658049553 + WORD $0x34870a01; WORD $0xd768226b // .quad -2925050114139026943 + WORD $0xf2cce375; WORD $0x81842f29 // .quad -9114107888677362827 + WORD $0x00d46641; WORD $0xe6a11583 // .quad -1828156321336891839 + WORD $0x6f801c53; WORD $0xa1e53af4 // .quad -6780948842419315629 + WORD $0xc1097fd1; WORD $0x60495ae3 // .quad 6938176635183661009 + WORD $0x8b602368; WORD $0xca5e89b1 // .quad -3864500034596756632 + WORD $0xb14bdfc5; WORD $0x385bb19c // .quad 4061034775552188357 + WORD $0xee382c42; WORD $0xfcf62c1d // .quad -218939024818557886 + WORD $0xdd9ed7b6; WORD $0x46729e03 // .quad 5076293469440235446 + WORD $0xb4e31ba9; WORD $0x9e19db92 // .quad -7054365918152680535 + WORD $0x6a8346d2; WORD $0x6c07a2c2 // .quad 7784369436827535058 + +TEXT ·__f64toa(SB), $0-24 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $80, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_f64toa: + MOVD out+0(FP), R0 + FMOVD val+8(FP), F0 + CALL ·__f64toa_arm64_entry__+24(SB) // _f64toa + MOVD R0, ret+16(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/f64toa_subr_arm64.go b/internal/native/neon/f64toa_subr_arm64.go new file mode 100644 index 000000000..ec82bee4c --- /dev/null +++ b/internal/native/neon/f64toa_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __f64toa_arm64_entry__() uintptr + +var ( + _subr__f64toa uintptr = __f64toa_arm64_entry__() + 12 +) + +const ( + _stack__f64toa = 48 +) + +var ( + _ = _subr__f64toa +) + +const ( + _ = _stack__f64toa +) diff --git a/internal/native/neon/fastfloat_arm64_test.go b/internal/native/neon/fastfloat_arm64_test.go new file mode 100644 index 000000000..f3c35f4fd --- /dev/null +++ b/internal/native/neon/fastfloat_arm64_test.go @@ -0,0 +1,142 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + `encoding/json` + `math` + `math/rand` + `strconv` + `testing` + + `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) + } + } +} diff --git a/internal/native/neon/fastint_arm64_test.go b/internal/native/neon/fastint_arm64_test.go new file mode 100644 index 000000000..d55fdfd22 --- /dev/null +++ b/internal/native/neon/fastint_arm64_test.go @@ -0,0 +1,155 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +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/internal/native/neon/get_by_path_arm64.go b/internal/native/neon/get_by_path_arm64.go new file mode 100644 index 000000000..691a73e3d --- /dev/null +++ b/internal/native/neon/get_by_path_arm64.go @@ -0,0 +1,35 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) { + return __get_by_path(s, p, path, m) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) diff --git a/internal/native/neon/get_by_path_arm64.s b/internal/native/neon/get_by_path_arm64.s new file mode 100644 index 000000000..613d36607 --- /dev/null +++ b/internal/native/neon/get_by_path_arm64.s @@ -0,0 +1,5137 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__get_by_path_arm64_entry__(SB), NOSPLIT, $208 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910383ff // add sp, sp, #224 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_1: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +lCPI0_2: + WORD $0x00000001; WORD $0x00000000 // .quad 1 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + // .p2align 2, 0x00 +_get_by_path: + MOVD.W R30, -224(RSP) // WORD $0xf8120ffe // str x30, [sp, #-224]! + WORD $0xa9086ffc // stp x28, x27, [sp, #128] + WORD $0xa90967fa // stp x26, x25, [sp, #144] + WORD $0xa90a5ff8 // stp x24, x23, [sp, #160] + WORD $0xa90b57f6 // stp x22, x21, [sp, #176] + WORD $0xa90c4ff4 // stp x20, x19, [sp, #192] + WORD $0xa90d7bfd // stp x29, x30, [sp, #208] + WORD $0xaa0003fe // mov x30, x0 + WORD $0xf9400448 // ldr x8, [x2, #8] + WORD $0x10fffd6a // adr x10, lCPI0_0 $-84(%rip) + WORD $0x10fffdc9 // adr x9, lCPI0_1 $-72(%rip) + WORD $0xb4013568 // cbz x8, LBB0_491 $9900(%rip) + WORD $0xf940004b // ldr x11, [x2] + WORD $0x8b081168 // add x8, x11, x8, lsl #4 + WORD $0xf9001fe8 // str x8, [sp, #56] + WORD $0x910023cd // add x13, x30, #8 + WORD $0x910103e8 // add x8, sp, #64 + WORD $0x9100810c // add x12, x8, #32 + WORD $0xf940002e // ldr x14, [x1] + WORD $0xb2400108 // orr x8, x8, #0x1 + WORD $0xa902a3ec // stp x12, x8, [sp, #40] + WORD $0x52800030 // mov w16, #1 + WORD $0xd284c000 // mov x0, #9728 + WORD $0xf2c00020 // movk x0, #1, lsl #32 + WORD $0x4f01e440 // movi.16b v0, #34 + WORD $0x3dc00141 // ldr q1, [x10, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x3dc00122 // ldr q2, [x9, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x4f02e783 // movi.16b v3, #92 + WORD $0x4f01e584 // movi.16b v4, #44 + WORD $0xb201e3e7 // mov x7, #-8608480567731124088 + WORD $0x4f06e7e5 // movi.16b v5, #223 + WORD $0xb202e3f3 // mov x19, #4919131752989213764 + WORD $0xb203e3f4 // mov x20, #2459565876494606882 + WORD $0x4f02e7a6 // movi.16b v6, #93 + WORD $0x4f02e767 // movi.16b v7, #91 + WORD $0x6f00e410 // movi.2d v16, #0000000000000000 + WORD $0x4f03e771 // movi.16b v17, #123 + WORD $0x4f03e7b2 // movi.16b v18, #125 +LBB0_2: + WORD $0xa94047d7 // ldp x23, x17, [x30] + WORD $0xeb1101df // cmp x14, x17 + WORD $0x54000202 // b.hs LBB0_7 $64(%rip) + WORD $0x386e6ae8 // ldrb w8, [x23, x14] + WORD $0x7100351f // cmp w8, #13 + WORD $0x540001a0 // b.eq LBB0_7 $52(%rip) + WORD $0x7100811f // cmp w8, #32 + WORD $0x54000160 // b.eq LBB0_7 $44(%rip) + WORD $0x51002d08 // sub w8, w8, #11 + WORD $0x3100091f // cmn w8, #2 + WORD $0x54000102 // b.hs LBB0_7 $32(%rip) + WORD $0xaa0e03ef // mov x15, x14 + WORD $0x910005e8 // add x8, x15, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x386f6aec // ldrb w12, [x23, x15] + WORD $0xf940016e // ldr x14, [x11] + WORD $0xb50008ce // cbnz x14, LBB0_30 $280(%rip) + WORD $0x14000e7a // b LBB0_780 $14824(%rip) +LBB0_7: + WORD $0x910005cf // add x15, x14, #1 + WORD $0xeb1101ff // cmp x15, x17 + WORD $0x54000122 // b.hs LBB0_11 $36(%rip) + WORD $0x386f6ae8 // ldrb w8, [x23, x15] + WORD $0x7100351f // cmp w8, #13 + WORD $0x540000c0 // b.eq LBB0_11 $24(%rip) + WORD $0x7100811f // cmp w8, #32 + WORD $0x54000080 // b.eq LBB0_11 $16(%rip) + WORD $0x51002d08 // sub w8, w8, #11 + WORD $0x3100091f // cmn w8, #2 + WORD $0x54000603 // b.lo LBB0_28 $192(%rip) +LBB0_11: + WORD $0x910009cf // add x15, x14, #2 + WORD $0xeb1101ff // cmp x15, x17 + WORD $0x54000122 // b.hs LBB0_15 $36(%rip) + WORD $0x386f6ae8 // ldrb w8, [x23, x15] + WORD $0x7100351f // cmp w8, #13 + WORD $0x540000c0 // b.eq LBB0_15 $24(%rip) + WORD $0x7100811f // cmp w8, #32 + WORD $0x54000080 // b.eq LBB0_15 $16(%rip) + WORD $0x51002d08 // sub w8, w8, #11 + WORD $0x3100091f // cmn w8, #2 + WORD $0x540004a3 // b.lo LBB0_28 $148(%rip) +LBB0_15: + WORD $0x91000dcf // add x15, x14, #3 + WORD $0xeb1101ff // cmp x15, x17 + WORD $0x54000122 // b.hs LBB0_19 $36(%rip) + WORD $0x386f6ae8 // ldrb w8, [x23, x15] + WORD $0x7100351f // cmp w8, #13 + WORD $0x540000c0 // b.eq LBB0_19 $24(%rip) + WORD $0x7100811f // cmp w8, #32 + WORD $0x54000080 // b.eq LBB0_19 $16(%rip) + WORD $0x51002d08 // sub w8, w8, #11 + WORD $0x3100091f // cmn w8, #2 + WORD $0x54000343 // b.lo LBB0_28 $104(%rip) +LBB0_19: + WORD $0x910011c8 // add x8, x14, #4 + WORD $0xeb08023f // cmp x17, x8 + WORD $0x540001a9 // b.ls LBB0_24 $52(%rip) + WORD $0x54000220 // b.eq LBB0_25 $68(%rip) + WORD $0x8b1102ec // add x12, x23, x17 +LBB0_22: + WORD $0x38e86aef // ldrsb w15, [x23, x8] + WORD $0x710081ff // cmp w15, #32 + WORD $0x9acf220f // lsl x15, x16, x15 + WORD $0x8a0001ef // and x15, x15, x0 + WORD $0xfa4099e4 // ccmp x15, #0, #4, ls + WORD $0x54000180 // b.eq LBB0_27 $48(%rip) + WORD $0x91000508 // add x8, x8, #1 + WORD $0xeb08023f // cmp x17, x8 + WORD $0x54ffff01 // b.ne LBB0_22 $-32(%rip) + WORD $0x14000007 // b LBB0_26 $28(%rip) +LBB0_24: + WORD $0x5280000c // mov w12, #0 + WORD $0xf9000028 // str x8, [x1] + WORD $0xf940016e // ldr x14, [x11] + WORD $0xb500022e // cbnz x14, LBB0_30 $68(%rip) + WORD $0x14000e45 // b LBB0_780 $14612(%rip) +LBB0_25: + WORD $0x8b0802ec // add x12, x23, x8 +LBB0_26: + WORD $0xcb170188 // sub x8, x12, x23 +LBB0_27: + WORD $0xaa0803ef // mov x15, x8 + WORD $0xeb11011f // cmp x8, x17 + WORD $0x540000e2 // b.hs LBB0_29 $28(%rip) +LBB0_28: + WORD $0x910005e8 // add x8, x15, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x386f6aec // ldrb w12, [x23, x15] + WORD $0xf940016e // ldr x14, [x11] + WORD $0xb50000ce // cbnz x14, LBB0_30 $24(%rip) + WORD $0x14000e3a // b LBB0_780 $14568(%rip) +LBB0_29: + WORD $0x5280000c // mov w12, #0 + WORD $0xaa0e03e8 // mov x8, x14 + WORD $0xf940016e // ldr x14, [x11] + WORD $0xb401c6ce // cbz x14, LBB0_780 $14552(%rip) +LBB0_30: + WORD $0x39405dce // ldrb w14, [x14, #23] + WORD $0x120011ce // and w14, w14, #0x1f + WORD $0x710009df // cmp w14, #2 + WORD $0x5400b680 // b.eq LBB0_319 $5840(%rip) + WORD $0x710061df // cmp w14, #24 + WORD $0x5401c601 // b.ne LBB0_780 $14528(%rip) + WORD $0x7101ed9f // cmp w12, #123 + WORD $0x5401c321 // b.ne LBB0_772 $14436(%rip) +LBB0_33: + WORD $0xf94001ae // ldr x14, [x13] + WORD $0xeb0e011f // cmp x8, x14 + WORD $0x54000162 // b.hs LBB0_38 $44(%rip) + WORD $0x38686aec // ldrb w12, [x23, x8] + WORD $0x7100359f // cmp w12, #13 + WORD $0x54000100 // b.eq LBB0_38 $32(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x540000c0 // b.eq LBB0_38 $24(%rip) + WORD $0x51002d8c // sub w12, w12, #11 + WORD $0x3100099f // cmn w12, #2 + WORD $0x54000062 // b.hs LBB0_38 $12(%rip) + WORD $0xaa0803f1 // mov x17, x8 + WORD $0x14000035 // b LBB0_58 $212(%rip) +LBB0_38: + WORD $0x91000511 // add x17, x8, #1 + WORD $0xeb0e023f // cmp x17, x14 + WORD $0x54000122 // b.hs LBB0_42 $36(%rip) + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_42 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_42 $16(%rip) + WORD $0x51002d8c // sub w12, w12, #11 + WORD $0x3100099f // cmn w12, #2 + WORD $0x54000543 // b.lo LBB0_58 $168(%rip) +LBB0_42: + WORD $0x91000911 // add x17, x8, #2 + WORD $0xeb0e023f // cmp x17, x14 + WORD $0x54000122 // b.hs LBB0_46 $36(%rip) + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_46 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_46 $16(%rip) + WORD $0x51002d8c // sub w12, w12, #11 + WORD $0x3100099f // cmn w12, #2 + WORD $0x540003e3 // b.lo LBB0_58 $124(%rip) +LBB0_46: + WORD $0x91000d11 // add x17, x8, #3 + WORD $0xeb0e023f // cmp x17, x14 + WORD $0x54000122 // b.hs LBB0_50 $36(%rip) + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_50 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_50 $16(%rip) + WORD $0x51002d8c // sub w12, w12, #11 + WORD $0x3100099f // cmn w12, #2 + WORD $0x54000283 // b.lo LBB0_58 $80(%rip) +LBB0_50: + WORD $0x91001111 // add x17, x8, #4 + WORD $0xeb1101df // cmp x14, x17 + WORD $0x5401bd89 // b.ls LBB0_775 $14256(%rip) + WORD $0x54000180 // b.eq LBB0_55 $48(%rip) + WORD $0x8b0e02ec // add x12, x23, x14 +LBB0_53: + WORD $0x38f16aef // ldrsb w15, [x23, x17] + WORD $0x710081ff // cmp w15, #32 + WORD $0x9acf220f // lsl x15, x16, x15 + WORD $0x8a0001ef // and x15, x15, x0 + WORD $0xfa4099e4 // ccmp x15, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_57 $28(%rip) + WORD $0x91000631 // add x17, x17, #1 + WORD $0xeb1101df // cmp x14, x17 + WORD $0x54ffff01 // b.ne LBB0_53 $-32(%rip) + WORD $0x14000002 // b LBB0_56 $8(%rip) +LBB0_55: + WORD $0x8b1102ec // add x12, x23, x17 +LBB0_56: + WORD $0xcb170191 // sub x17, x12, x23 +LBB0_57: + WORD $0xeb0e023f // cmp x17, x14 + WORD $0x5401bb02 // b.hs LBB0_772 $14176(%rip) +LBB0_58: + WORD $0x91000628 // add x8, x17, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100899f // cmp w12, #34 + WORD $0x5401ba21 // b.ne LBB0_771 $14148(%rip) + WORD $0xf94001bb // ldr x27, [x13] + WORD $0xeb080376 // subs x22, x27, x8 + WORD $0x5401c780 // b.eq LBB0_805 $14576(%rip) + WORD $0xf940056c // ldr x12, [x11, #8] + WORD $0xa9406598 // ldp x24, x25, [x12] + WORD $0x8b0802fa // add x26, x23, x8 + WORD $0xf10102df // cmp x22, #64 + WORD $0x54008403 // b.lo LBB0_253 $4224(%rip) + WORD $0xd280000e // mov x14, #0 + WORD $0x9280001c // mov x28, #-1 + WORD $0x92800015 // mov x21, #-1 +LBB0_62: + WORD $0x8b0802ec // add x12, x23, x8 + WORD $0xad405193 // ldp q19, q20, [x12] + WORD $0xad415995 // ldp q21, q22, [x12, #32] + WORD $0x6e208e77 // cmeq.16b v23, v19, v0 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e238e73 // cmeq.16b v19, v19, v3 + WORD $0x6e238e94 // cmeq.16b v20, v20, v3 + WORD $0x6e238eb5 // cmeq.16b v21, v21, v3 + WORD $0x6e238ed6 // cmeq.16b v22, v22, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x4e211f17 // and.16b v23, v24, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ef // fmov w15, s23 + WORD $0x4e211f37 // and.16b v23, v25, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e2 // fmov w2, s23 + WORD $0x4e211f57 // and.16b v23, v26, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e4 // fmov w4, s23 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260265 // fmov w5, s19 + WORD $0x4e211e93 // and.16b v19, v20, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x4e211eb3 // and.16b v19, v21, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026a // fmov w10, s19 + WORD $0x4e211ed3 // and.16b v19, v22, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260266 // fmov w6, s19 + WORD $0xd3607c42 // lsl x2, x2, #32 + WORD $0xb3503c82 // bfi x2, x4, #48, #16 + WORD $0x53103def // lsl w15, w15, #16 + WORD $0xaa0f004f // orr x15, x2, x15 + WORD $0xaa0c01ef // orr x15, x15, x12 + WORD $0xd3607d4a // lsl x10, x10, #32 + WORD $0xb3503cca // bfi x10, x6, #48, #16 + WORD $0x53103d29 // lsl w9, w9, #16 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0xaa05012c // orr x12, x9, x5 + WORD $0xb500010c // cbnz x12, LBB0_66 $32(%rip) + WORD $0xb50001ae // cbnz x14, LBB0_67 $52(%rip) + WORD $0xb50002ef // cbnz x15, LBB0_68 $92(%rip) +LBB0_65: + WORD $0xd10102d6 // sub x22, x22, #64 + WORD $0x91010108 // add x8, x8, #64 + WORD $0xf100fedf // cmp x22, #63 + WORD $0x54fff8a8 // b.hi LBB0_62 $-236(%rip) + WORD $0x140003aa // b LBB0_244 $3752(%rip) +LBB0_66: + WORD $0xb10006bf // cmn x21, #1 + WORD $0xdac00189 // rbit x9, x12 + WORD $0xdac01129 // clz x9, x9 + WORD $0x8b080129 // add x9, x9, x8 + WORD $0x9a89139c // csel x28, x28, x9, ne + WORD $0x9a8912b5 // csel x21, x21, x9, ne +LBB0_67: + WORD $0x8a2e0189 // bic x9, x12, x14 + WORD $0xaa0905ca // orr x10, x14, x9, lsl #1 + WORD $0x8a2a018c // bic x12, x12, x10 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab090189 // adds x9, x12, x9 + WORD $0x1a9f37ee // cset w14, hs + WORD $0xd37ff929 // lsl x9, x9, #1 + WORD $0xd200f129 // eor x9, x9, #0x5555555555555555 + WORD $0x8a0a0129 // and x9, x9, x10 + WORD $0x8a2901ef // bic x15, x15, x9 + WORD $0xb4fffd6f // cbz x15, LBB0_65 $-84(%rip) +LBB0_68: + WORD $0xdac001e9 // rbit x9, x15 + WORD $0xdac01129 // clz x9, x9 + WORD $0x8b080128 // add x8, x9, x8 + WORD $0x91000508 // add x8, x8, #1 + WORD $0xb7f9bc48 // tbnz x8, #63, LBB0_806 $14216(%rip) +LBB0_69: + WORD $0xf9000028 // str x8, [x1] + WORD $0xb100079f // cmn x28, #1 + WORD $0x54000060 // b.eq LBB0_71 $12(%rip) + WORD $0xeb08039f // cmp x28, x8 + WORD $0x5400798d // b.le LBB0_254 $3888(%rip) +LBB0_71: + WORD $0xcb110109 // sub x9, x8, x17 + WORD $0xd100092c // sub x12, x9, #2 + WORD $0xaa190189 // orr x9, x12, x25 + WORD $0xb4000629 // cbz x9, LBB0_81 $196(%rip) + WORD $0xeb19019f // cmp x12, x25 + WORD $0x54000221 // b.ne LBB0_76 $68(%rip) + WORD $0xd280000e // mov x14, #0 + WORD $0xaa1903ef // mov x15, x25 +LBB0_74: + WORD $0xf10041ec // subs x12, x15, #16 + WORD $0x540001e3 // b.lo LBB0_77 $60(%rip) + WORD $0x3cee6b53 // ldr q19, [x26, x14] + WORD $0x3cee6b14 // ldr q20, [x24, x14] + WORD $0x6e338e93 // cmeq.16b v19, v20, v19 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x2a2903e9 // mvn w9, w9 + WORD $0x910041ce // add x14, x14, #16 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0x12003d29 // and w9, w9, #0xffff + WORD $0x34fffe69 // cbz w9, LBB0_74 $-52(%rip) +LBB0_76: + WORD $0xd280000e // mov x14, #0 + WORD $0x1400001e // b LBB0_82 $120(%rip) +LBB0_77: + WORD $0x0b170229 // add w9, w17, w23 + WORD $0x0b0e0129 // add w9, w9, w14 + WORD $0x11000529 // add w9, w9, #1 + WORD $0x92402d29 // and x9, x9, #0xfff + WORD $0x8b0e0311 // add x17, x24, x14 + WORD $0xf13fc13f // cmp x9, #4080 + WORD $0x54000288 // b.hi LBB0_80 $80(%rip) + WORD $0x92402e29 // and x9, x17, #0xfff + WORD $0xf13fc53f // cmp x9, #4081 + WORD $0x54000222 // b.hs LBB0_80 $68(%rip) + WORD $0x3cee6b53 // ldr q19, [x26, x14] + WORD $0x3cee6b14 // ldr q20, [x24, x14] + WORD $0x6e338e93 // cmeq.16b v19, v20, v19 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x529fffea // mov w10, #65535 + WORD $0x6a290149 // bics w9, w10, w9 + WORD $0x1a9f17ea // cset w10, eq + WORD $0xdac00129 // rbit x9, x9 + WORD $0xdac01129 // clz x9, x9 + WORD $0xeb0f013f // cmp x9, x15 + WORD $0x1a9f37e9 // cset w9, hs + WORD $0x2a09014e // orr w14, w10, w9 + WORD $0x14000004 // b LBB0_82 $16(%rip) +LBB0_80: + WORD $0xeb0e033f // cmp x25, x14 + WORD $0x54002181 // b.ne LBB0_177 $1072(%rip) +LBB0_81: + WORD $0x5280002e // mov w14, #1 +LBB0_82: + WORD $0xf94001b5 // ldr x21, [x13] + WORD $0xeb15011f // cmp x8, x21 + WORD $0x54000162 // b.hs LBB0_87 $44(%rip) + WORD $0x38686aec // ldrb w12, [x23, x8] + WORD $0x7100359f // cmp w12, #13 + WORD $0x54000100 // b.eq LBB0_87 $32(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x540000c0 // b.eq LBB0_87 $24(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000062 // b.hs LBB0_87 $12(%rip) + WORD $0xaa0803f1 // mov x17, x8 + WORD $0x14000035 // b LBB0_107 $212(%rip) +LBB0_87: + WORD $0x91000511 // add x17, x8, #1 + WORD $0xeb15023f // cmp x17, x21 + WORD $0x54000122 // b.hs LBB0_91 $36(%rip) + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_91 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_91 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000543 // b.lo LBB0_107 $168(%rip) +LBB0_91: + WORD $0x91000911 // add x17, x8, #2 + WORD $0xeb15023f // cmp x17, x21 + WORD $0x54000122 // b.hs LBB0_95 $36(%rip) + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_95 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_95 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x540003e3 // b.lo LBB0_107 $124(%rip) +LBB0_95: + WORD $0x91000d11 // add x17, x8, #3 + WORD $0xeb15023f // cmp x17, x21 + WORD $0x54000122 // b.hs LBB0_99 $36(%rip) + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_99 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_99 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000283 // b.lo LBB0_107 $80(%rip) +LBB0_99: + WORD $0x91001111 // add x17, x8, #4 + WORD $0xeb1102bf // cmp x21, x17 + WORD $0x5401a1c9 // b.ls LBB0_775 $13368(%rip) + WORD $0x54000180 // b.eq LBB0_104 $48(%rip) + WORD $0x8b1502ec // add x12, x23, x21 +LBB0_102: + WORD $0x38f16ae9 // ldrsb w9, [x23, x17] + WORD $0x7100813f // cmp w9, #32 + WORD $0x9ac92209 // lsl x9, x16, x9 + WORD $0x8a000129 // and x9, x9, x0 + WORD $0xfa409924 // ccmp x9, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_106 $28(%rip) + WORD $0x91000631 // add x17, x17, #1 + WORD $0xeb1102bf // cmp x21, x17 + WORD $0x54ffff01 // b.ne LBB0_102 $-32(%rip) + WORD $0x14000002 // b LBB0_105 $8(%rip) +LBB0_104: + WORD $0x8b1102ec // add x12, x23, x17 +LBB0_105: + WORD $0xcb170191 // sub x17, x12, x23 +LBB0_106: + WORD $0xeb15023f // cmp x17, x21 + WORD $0x54019f42 // b.hs LBB0_772 $13288(%rip) +LBB0_107: + WORD $0x91000628 // add x8, x17, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38716ae9 // ldrb w9, [x23, x17] + WORD $0x7100e93f // cmp w9, #58 + WORD $0x54019ea1 // b.ne LBB0_772 $13268(%rip) + WORD $0xb50100ce // cbnz x14, LBB0_490 $8216(%rip) + WORD $0xf94001b5 // ldr x21, [x13] + WORD $0xeb15011f // cmp x8, x21 + WORD $0x54000162 // b.hs LBB0_114 $44(%rip) + WORD $0x38686aec // ldrb w12, [x23, x8] + WORD $0x7100359f // cmp w12, #13 + WORD $0x54000100 // b.eq LBB0_114 $32(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x540000c0 // b.eq LBB0_114 $24(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000062 // b.hs LBB0_114 $12(%rip) + WORD $0xaa0803ee // mov x14, x8 + WORD $0x14000035 // b LBB0_134 $212(%rip) +LBB0_114: + WORD $0x91000a2e // add x14, x17, #2 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x54000122 // b.hs LBB0_118 $36(%rip) + WORD $0x386e6aec // ldrb w12, [x23, x14] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_118 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_118 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000543 // b.lo LBB0_134 $168(%rip) +LBB0_118: + WORD $0x91000e2e // add x14, x17, #3 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x54000122 // b.hs LBB0_122 $36(%rip) + WORD $0x386e6aec // ldrb w12, [x23, x14] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_122 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_122 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x540003e3 // b.lo LBB0_134 $124(%rip) +LBB0_122: + WORD $0x9100122e // add x14, x17, #4 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x54000122 // b.hs LBB0_126 $36(%rip) + WORD $0x386e6aec // ldrb w12, [x23, x14] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_126 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_126 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000283 // b.lo LBB0_134 $80(%rip) +LBB0_126: + WORD $0x9100162e // add x14, x17, #5 + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54000809 // b.ls LBB0_147 $256(%rip) + WORD $0x54000180 // b.eq LBB0_131 $48(%rip) + WORD $0x8b1502ec // add x12, x23, x21 +LBB0_129: + WORD $0x38ee6ae9 // ldrsb w9, [x23, x14] + WORD $0x7100813f // cmp w9, #32 + WORD $0x9ac92209 // lsl x9, x16, x9 + WORD $0x8a000129 // and x9, x9, x0 + WORD $0xfa409924 // ccmp x9, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_133 $28(%rip) + WORD $0x910005ce // add x14, x14, #1 + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54ffff01 // b.ne LBB0_129 $-32(%rip) + WORD $0x14000002 // b LBB0_132 $8(%rip) +LBB0_131: + WORD $0x8b0e02ec // add x12, x23, x14 +LBB0_132: + WORD $0xcb17018e // sub x14, x12, x23 +LBB0_133: + WORD $0xeb1501df // cmp x14, x21 + WORD $0x540006e2 // b.hs LBB0_150 $220(%rip) +LBB0_134: + WORD $0x910005c8 // add x8, x14, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38ee6aec // ldrsb w12, [x23, x14] + WORD $0x7101ed9f // cmp w12, #123 + WORD $0x54000568 // b.hi LBB0_147 $172(%rip) +Lloh0: + WORD $0x1001ae6f // adr x15, LJTI0_1 $13772(%rip) +Lloh1: + WORD $0x910001ef // add x15, x15, LJTI0_1@PAGEOFF $0(%rip) + WORD $0x10000089 // adr x9, LBB0_136 $16(%rip) + WORD $0x786c79ea // ldrh w10, [x15, x12, lsl #1] + WORD $0x8b0a0929 // add x9, x9, x10, lsl #2 + WORD $0xd61f0120 // br x9 +LBB0_136: + WORD $0xf94001a9 // ldr x9, [x13] + WORD $0xcb08012e // sub x14, x9, x8 + WORD $0xf10041df // cmp x14, #16 + WORD $0x540001e3 // b.lo LBB0_139 $60(%rip) +LBB0_137: + WORD $0x3ce86af3 // ldr q19, [x23, x8] + WORD $0x6e248e74 // cmeq.16b v20, v19, v4 + WORD $0x4e251e73 // and.16b v19, v19, v5 + WORD $0x6e268e73 // cmeq.16b v19, v19, v6 + WORD $0x4eb41e73 // orr.16b v19, v19, v20 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026c // fmov w12, s19 + WORD $0x3500034c // cbnz w12, LBB0_148 $104(%rip) + WORD $0xd10041ce // sub x14, x14, #16 + WORD $0x91004108 // add x8, x8, #16 + WORD $0xf1003ddf // cmp x14, #15 + WORD $0x54fffe68 // b.hi LBB0_137 $-52(%rip) +LBB0_139: + WORD $0x8b0802ef // add x15, x23, x8 + WORD $0xb40001ee // cbz x14, LBB0_146 $60(%rip) + WORD $0x8b0e01ec // add x12, x15, x14 + WORD $0xcb1701e8 // sub x8, x15, x23 +LBB0_141: + WORD $0x394001f1 // ldrb w17, [x15] + WORD $0x7100b23f // cmp w17, #44 + WORD $0x54000240 // b.eq LBB0_149 $72(%rip) + WORD $0x7101f63f // cmp w17, #125 + WORD $0x54000200 // b.eq LBB0_149 $64(%rip) + WORD $0x7101763f // cmp w17, #93 + WORD $0x540001c0 // b.eq LBB0_149 $56(%rip) + WORD $0x910005ef // add x15, x15, #1 + WORD $0x91000508 // add x8, x8, #1 + WORD $0xf10005ce // subs x14, x14, #1 + WORD $0x54fffec1 // b.ne LBB0_141 $-40(%rip) + WORD $0xaa0c03ef // mov x15, x12 +LBB0_146: + WORD $0xcb1701e8 // sub x8, x15, x23 + WORD $0x14000007 // b LBB0_149 $28(%rip) +LBB0_147: + WORD $0xf900002e // str x14, [x1] + WORD $0xaa0e03e8 // mov x8, x14 + WORD $0x14000005 // b LBB0_150 $20(%rip) +LBB0_148: + WORD $0x5ac00189 // rbit w9, w12 + WORD $0x5ac01129 // clz w9, w9 + WORD $0x8b080128 // add x8, x9, x8 +LBB0_149: + WORD $0xf9000028 // str x8, [x1] +LBB0_150: + WORD $0xa9403bd7 // ldp x23, x14, [x30] + WORD $0xeb0e011f // cmp x8, x14 + WORD $0x54000162 // b.hs LBB0_155 $44(%rip) + WORD $0x38686aec // ldrb w12, [x23, x8] + WORD $0x7100359f // cmp w12, #13 + WORD $0x54000100 // b.eq LBB0_155 $32(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x540000c0 // b.eq LBB0_155 $24(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000062 // b.hs LBB0_155 $12(%rip) + WORD $0xaa0803f1 // mov x17, x8 + WORD $0x14000035 // b LBB0_175 $212(%rip) +LBB0_155: + WORD $0x91000511 // add x17, x8, #1 + WORD $0xeb0e023f // cmp x17, x14 + WORD $0x54000122 // b.hs LBB0_159 $36(%rip) + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_159 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_159 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000543 // b.lo LBB0_175 $168(%rip) +LBB0_159: + WORD $0x91000911 // add x17, x8, #2 + WORD $0xeb0e023f // cmp x17, x14 + WORD $0x54000122 // b.hs LBB0_163 $36(%rip) + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_163 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_163 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x540003e3 // b.lo LBB0_175 $124(%rip) +LBB0_163: + WORD $0x91000d11 // add x17, x8, #3 + WORD $0xeb0e023f // cmp x17, x14 + WORD $0x54000122 // b.hs LBB0_167 $36(%rip) + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_167 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_167 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000283 // b.lo LBB0_175 $80(%rip) +LBB0_167: + WORD $0x91001111 // add x17, x8, #4 + WORD $0xeb1101df // cmp x14, x17 + WORD $0x54018a09 // b.ls LBB0_775 $12608(%rip) + WORD $0x54000180 // b.eq LBB0_172 $48(%rip) + WORD $0x8b0e02ec // add x12, x23, x14 +LBB0_170: + WORD $0x38f16ae9 // ldrsb w9, [x23, x17] + WORD $0x7100813f // cmp w9, #32 + WORD $0x9ac92209 // lsl x9, x16, x9 + WORD $0x8a000129 // and x9, x9, x0 + WORD $0xfa409924 // ccmp x9, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_174 $28(%rip) + WORD $0x91000631 // add x17, x17, #1 + WORD $0xeb1101df // cmp x14, x17 + WORD $0x54ffff01 // b.ne LBB0_170 $-32(%rip) + WORD $0x14000002 // b LBB0_173 $8(%rip) +LBB0_172: + WORD $0x8b1102ec // add x12, x23, x17 +LBB0_173: + WORD $0xcb170191 // sub x17, x12, x23 +LBB0_174: + WORD $0xeb0e023f // cmp x17, x14 + WORD $0x54018782 // b.hs LBB0_772 $12528(%rip) +LBB0_175: + WORD $0x91000628 // add x8, x17, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38716aec // ldrb w12, [x23, x17] + WORD $0x7100b19f // cmp w12, #44 + WORD $0x54ffc3e0 // b.eq LBB0_33 $-1924(%rip) + WORD $0x14000c34 // b LBB0_771 $12496(%rip) +LBB0_176: + WORD $0x910011cc // add x12, x14, #4 + WORD $0xf94001a9 // ldr x9, [x13] + WORD $0xeb09019f // cmp x12, x9 + WORD $0x54fff6c8 // b.hi LBB0_150 $-296(%rip) + WORD $0x14000052 // b LBB0_191 $328(%rip) +LBB0_177: + WORD $0x8b0e034c // add x12, x26, x14 +LBB0_178: + WORD $0x39400189 // ldrb w9, [x12] + WORD $0x3940022a // ldrb w10, [x17] + WORD $0x6b0a013f // cmp w9, w10 + WORD $0x54ffda61 // b.ne LBB0_76 $-1204(%rip) + WORD $0x91000631 // add x17, x17, #1 + WORD $0x9100058c // add x12, x12, #1 + WORD $0x5280002e // mov w14, #1 + WORD $0xf10005ef // subs x15, x15, #1 + WORD $0x54ffff01 // b.ne LBB0_178 $-32(%rip) + WORD $0x17fffeec // b LBB0_82 $-1104(%rip) +LBB0_180: + WORD $0xf94001ac // ldr x12, [x13] + WORD $0xcb08018f // sub x15, x12, x8 + WORD $0xf10081ff // cmp x15, #32 + WORD $0x54006ccb // b.lt LBB0_297 $3480(%rip) + WORD $0xd2800011 // mov x17, #0 + WORD $0xd2800016 // mov x22, #0 + WORD $0x8b0e02ef // add x15, x23, x14 + WORD $0xcb0e0195 // sub x21, x12, x14 + WORD $0x528003f8 // mov w24, #31 +LBB0_182: + WORD $0x8b1101e9 // add x9, x15, x17 + WORD $0x3cc01133 // ldur q19, [x9, #1] + WORD $0x3cc11134 // ldur q20, [x9, #17] + WORD $0x6e208e75 // cmeq.16b v21, v19, v0 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602b9 // fmov w25, s21 + WORD $0x6e208e95 // cmeq.16b v21, v20, v0 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602a9 // fmov w9, s21 + WORD $0x33103d39 // bfi w25, w9, #16, #16 + WORD $0x6e238e73 // cmeq.16b v19, v19, v3 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026c // fmov w12, s19 + WORD $0x6e238e93 // cmeq.16b v19, v20, v3 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x33103d2c // bfi w12, w9, #16, #16 + WORD $0x7100019f // cmp w12, #0 + WORD $0xfa400ac0 // ccmp x22, #0, #0, eq + WORD $0x540001c0 // b.eq LBB0_184 $56(%rip) + WORD $0x0a360189 // bic w9, w12, w22 + WORD $0x2a0906ca // orr w10, w22, w9, lsl #1 + WORD $0x3201f3e2 // mov w2, #-1431655766 + WORD $0x0a02018c // and w12, w12, w2 + WORD $0x0a2a018c // bic w12, w12, w10 + WORD $0x2b090189 // adds w9, w12, w9 + WORD $0x1a9f37f6 // cset w22, hs + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a090589 // eor w9, w12, w9, lsl #1 + WORD $0x0a0a0129 // and w9, w9, w10 + WORD $0x2a2903e9 // mvn w9, w9 + WORD $0x8a190139 // and x25, x9, x25 + WORD $0x14000002 // b LBB0_185 $8(%rip) +LBB0_184: + WORD $0xd2800016 // mov x22, #0 +LBB0_185: + WORD $0x35004179 // cbnz w25, LBB0_243 $2092(%rip) + WORD $0x91008231 // add x17, x17, #32 + WORD $0xd1008318 // sub x24, x24, #32 + WORD $0x8b1802a9 // add x9, x21, x24 + WORD $0xf100fd3f // cmp x9, #63 + WORD $0x54fffa2c // b.gt LBB0_182 $-188(%rip) + WORD $0xb5006f56 // cbnz x22, LBB0_317 $3560(%rip) + WORD $0x8b0e02e9 // add x9, x23, x14 + WORD $0x8b110129 // add x9, x9, x17 + WORD $0x9100052e // add x14, x9, #1 + WORD $0xaa3103e9 // mvn x9, x17 + WORD $0x8b15012f // add x15, x9, x21 +LBB0_189: + WORD $0xf10005ff // cmp x15, #1 + WORD $0x540045ca // b.ge LBB0_250 $2232(%rip) + WORD $0x17ffff68 // b LBB0_150 $-608(%rip) +LBB0_190: + WORD $0x910015cc // add x12, x14, #5 + WORD $0xf94001a9 // ldr x9, [x13] + WORD $0xeb09019f // cmp x12, x9 + WORD $0x54ffec88 // b.hi LBB0_150 $-624(%rip) +LBB0_191: + WORD $0xf900002c // str x12, [x1] + WORD $0xaa0c03e8 // mov x8, x12 + WORD $0x17ffff61 // b LBB0_150 $-636(%rip) +LBB0_192: + WORD $0xd2800015 // mov x21, #0 + WORD $0xd2800019 // mov x25, #0 + WORD $0xd2800011 // mov x17, #0 + WORD $0xd2800018 // mov x24, #0 + WORD $0xf94001a9 // ldr x9, [x13] + WORD $0xcb08013a // sub x26, x9, x8 + WORD $0x8b0802e8 // add x8, x23, x8 + WORD $0x14000009 // b LBB0_194 $36(%rip) +LBB0_193: + WORD $0x937ffdd5 // asr x21, x14, #63 + WORD $0x9e6701f3 // fmov d19, x15 + WORD $0x0e205a73 // cnt.8b v19, v19 + WORD $0x2e303a73 // uaddlv.8b h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x8b110131 // add x17, x9, x17 + WORD $0x91010108 // add x8, x8, #64 + WORD $0xaa1703fa // mov x26, x23 +LBB0_194: + WORD $0xf1010357 // subs x23, x26, #64 + WORD $0x5400160b // b.lt LBB0_201 $704(%rip) +LBB0_195: + WORD $0xad405516 // ldp q22, q21, [x8] + WORD $0xad414d14 // ldp q20, q19, [x8, #32] + WORD $0x6e238ed7 // cmeq.16b v23, v22, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e9 // fmov w9, s23 + WORD $0x6e238eb7 // cmeq.16b v23, v21, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e238e97 // cmeq.16b v23, v20, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x6e238e77 // cmeq.16b v23, v19, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ee // fmov w14, s23 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503dcc // bfi x12, x14, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa09014c // orr x12, x10, x9 + WORD $0xaa190189 // orr x9, x12, x25 + WORD $0xb5000089 // cbnz x9, LBB0_197 $16(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x9280000e // mov x14, #-1 + WORD $0x1400000b // b LBB0_198 $44(%rip) +LBB0_197: + WORD $0x8a390189 // bic x9, x12, x25 + WORD $0xaa09072a // orr x10, x25, x9, lsl #1 + WORD $0x8a2a018c // bic x12, x12, x10 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab090189 // adds x9, x12, x9 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff929 // lsl x9, x9, #1 + WORD $0xd200f129 // eor x9, x9, #0x5555555555555555 + WORD $0x8a0a0129 // and x9, x9, x10 + WORD $0xaa2903ee // mvn x14, x9 +LBB0_198: + WORD $0x6e208ed7 // cmeq.16b v23, v22, v0 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x6e208e99 // cmeq.16b v25, v20, v0 + WORD $0x4e211f39 // and.16b v25, v25, v1 + WORD $0x6e208e7a // cmeq.16b v26, v19, v0 + WORD $0x4e211f5a // and.16b v26, v26, v1 + WORD $0x4e02035a // tbl.16b v26, { v26 }, v2 + WORD $0x4e71bb5a // addv.8h h26, v26 + WORD $0x1e260349 // fmov w9, s26 + WORD $0xd3503d29 // lsl x9, x9, #48 + WORD $0x4e020339 // tbl.16b v25, { v25 }, v2 + WORD $0x4e71bb39 // addv.8h h25, v25 + WORD $0x1e26032a // fmov w10, s25 + WORD $0xb3603d49 // bfi x9, x10, #32, #16 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a0129 // orr x9, x9, x10 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0xaa0a0129 // orr x9, x9, x10 + WORD $0x8a0e0129 // and x9, x9, x14 + WORD $0x9200e12a // and x10, x9, #0x1111111111111111 + WORD $0x9203e12c // and x12, x9, #0x2222222222222222 + WORD $0x9202e12e // and x14, x9, #0x4444444444444444 + WORD $0x9201e129 // and x9, x9, #0x8888888888888888 + WORD $0xb200e3e6 // mov x6, #1229782938247303441 + WORD $0x9b067d4f // mul x15, x10, x6 + WORD $0x9b077d82 // mul x2, x12, x7 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b137dc2 // mul x2, x14, x19 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b147d22 // mul x2, x9, x20 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b147d42 // mul x2, x10, x20 + WORD $0x9b067d84 // mul x4, x12, x6 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b077dc4 // mul x4, x14, x7 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b137d24 // mul x4, x9, x19 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b137d44 // mul x4, x10, x19 + WORD $0x9b147d85 // mul x5, x12, x20 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b067dc5 // mul x5, x14, x6 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b077d25 // mul x5, x9, x7 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b077d4a // mul x10, x10, x7 + WORD $0x9b137d8c // mul x12, x12, x19 + WORD $0xca0c014a // eor x10, x10, x12 + WORD $0x9b147dcc // mul x12, x14, x20 + WORD $0xca0c014a // eor x10, x10, x12 + WORD $0x9b067d29 // mul x9, x9, x6 + WORD $0xca090149 // eor x9, x10, x9 + WORD $0x9200e1ea // and x10, x15, #0x1111111111111111 + WORD $0x9203e04c // and x12, x2, #0x2222222222222222 + WORD $0x9202e08e // and x14, x4, #0x4444444444444444 + WORD $0x9201e129 // and x9, x9, #0x8888888888888888 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa0e014a // orr x10, x10, x14 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0xca15012e // eor x14, x9, x21 + WORD $0x6e278ed7 // cmeq.16b v23, v22, v7 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e9 // fmov w9, s23 + WORD $0x6e278eb7 // cmeq.16b v23, v21, v7 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e278e97 // cmeq.16b v23, v20, v7 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x6e278e77 // cmeq.16b v23, v19, v7 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ef // fmov w15, s23 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503dec // bfi x12, x15, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0x8a2e012f // bic x15, x9, x14 + WORD $0x6e268ed6 // cmeq.16b v22, v22, v6 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c9 // fmov w9, s22 + WORD $0x6e268eb5 // cmeq.16b v21, v21, v6 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x6e268e94 // cmeq.16b v20, v20, v6 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x6e268e73 // cmeq.16b v19, v19, v6 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260262 // fmov w2, s19 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503c4c // bfi x12, x2, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0xea2e012c // bics x12, x9, x14 + WORD $0x54ffeaa0 // b.eq LBB0_193 $-684(%rip) +LBB0_199: + WORD $0xd1000595 // sub x21, x12, #1 + WORD $0x8a0f02a9 // and x9, x21, x15 + WORD $0x9e670133 // fmov d19, x9 + WORD $0x0e205a73 // cnt.8b v19, v19 + WORD $0x2e303a73 // uaddlv.8b h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x8b110129 // add x9, x9, x17 + WORD $0xeb18013f // cmp x9, x24 + WORD $0x540025c9 // b.ls LBB0_242 $1208(%rip) + WORD $0x91000718 // add x24, x24, #1 + WORD $0xea0c02ac // ands x12, x21, x12 + WORD $0x54fffea1 // b.ne LBB0_199 $-44(%rip) + WORD $0x17ffff48 // b LBB0_193 $-736(%rip) +LBB0_201: + WORD $0xf100035f // cmp x26, #0 + WORD $0x540054cd // b.le LBB0_316 $2712(%rip) + WORD $0xad0343f0 // stp q16, q16, [sp, #96] + WORD $0xad0243f0 // stp q16, q16, [sp, #64] + WORD $0x92402d09 // and x9, x8, #0xfff + WORD $0xf13f053f // cmp x9, #4033 + WORD $0x54ffe963 // b.lo LBB0_195 $-724(%rip) + WORD $0xf100834f // subs x15, x26, #32 + WORD $0x54000103 // b.lo LBB0_205 $32(%rip) + WORD $0x3dc00113 // ldr q19, [x8] + WORD $0x3d8013f3 // str q19, [sp, #64] + WORD $0x3dc00513 // ldr q19, [x8, #16] + WORD $0x3d8017f3 // str q19, [sp, #80] + WORD $0x91008108 // add x8, x8, #32 + WORD $0xf94017ee // ldr x14, [sp, #40] + WORD $0x14000003 // b LBB0_206 $12(%rip) +LBB0_205: + WORD $0x910103ee // add x14, sp, #64 + WORD $0xaa1a03ef // mov x15, x26 +LBB0_206: + WORD $0xf10041ec // subs x12, x15, #16 + WORD $0x54000243 // b.lo LBB0_212 $72(%rip) + WORD $0x3cc10513 // ldr q19, [x8], #16 + WORD $0x3c8105d3 // str q19, [x14], #16 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10021ec // subs x12, x15, #8 + WORD $0x540001e2 // b.hs LBB0_213 $60(%rip) +LBB0_208: + WORD $0xf10011ec // subs x12, x15, #4 + WORD $0x54000243 // b.lo LBB0_214 $72(%rip) +LBB0_209: + WORD $0xb8404509 // ldr w9, [x8], #4 + WORD $0xb80045c9 // str w9, [x14], #4 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10009ec // subs x12, x15, #2 + WORD $0x540001e2 // b.hs LBB0_215 $60(%rip) +LBB0_210: + WORD $0xb400024f // cbz x15, LBB0_216 $72(%rip) +LBB0_211: + WORD $0x39400108 // ldrb w8, [x8] + WORD $0x390001c8 // strb w8, [x14] + WORD $0x910103e8 // add x8, sp, #64 + WORD $0x17ffff2d // b LBB0_195 $-844(%rip) +LBB0_212: + WORD $0xf10021ec // subs x12, x15, #8 + WORD $0x54fffe63 // b.lo LBB0_208 $-52(%rip) +LBB0_213: + WORD $0xf8408509 // ldr x9, [x8], #8 + WORD $0xf80085c9 // str x9, [x14], #8 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10011ec // subs x12, x15, #4 + WORD $0x54fffe02 // b.hs LBB0_209 $-64(%rip) +LBB0_214: + WORD $0xf10009ec // subs x12, x15, #2 + WORD $0x54fffe63 // b.lo LBB0_210 $-52(%rip) +LBB0_215: + WORD $0x78402509 // ldrh w9, [x8], #2 + WORD $0x780025c9 // strh w9, [x14], #2 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xb5fffe0f // cbnz x15, LBB0_211 $-64(%rip) +LBB0_216: + WORD $0x910103e8 // add x8, sp, #64 + WORD $0x17ffff1e // b LBB0_195 $-904(%rip) +LBB0_217: + WORD $0xd2800015 // mov x21, #0 + WORD $0xd2800019 // mov x25, #0 + WORD $0xd2800011 // mov x17, #0 + WORD $0xd2800018 // mov x24, #0 + WORD $0xf94001a9 // ldr x9, [x13] + WORD $0xcb08013a // sub x26, x9, x8 + WORD $0x8b0802e8 // add x8, x23, x8 + WORD $0x14000009 // b LBB0_219 $36(%rip) +LBB0_218: + WORD $0x937ffdd5 // asr x21, x14, #63 + WORD $0x9e6701f3 // fmov d19, x15 + WORD $0x0e205a73 // cnt.8b v19, v19 + WORD $0x2e303a73 // uaddlv.8b h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x8b110131 // add x17, x9, x17 + WORD $0x91010108 // add x8, x8, #64 + WORD $0xaa1703fa // mov x26, x23 +LBB0_219: + WORD $0xf1010357 // subs x23, x26, #64 + WORD $0x5400160b // b.lt LBB0_226 $704(%rip) +LBB0_220: + WORD $0xad405516 // ldp q22, q21, [x8] + WORD $0xad414d14 // ldp q20, q19, [x8, #32] + WORD $0x6e238ed7 // cmeq.16b v23, v22, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e9 // fmov w9, s23 + WORD $0x6e238eb7 // cmeq.16b v23, v21, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e238e97 // cmeq.16b v23, v20, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x6e238e77 // cmeq.16b v23, v19, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ee // fmov w14, s23 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503dcc // bfi x12, x14, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa09014c // orr x12, x10, x9 + WORD $0xaa190189 // orr x9, x12, x25 + WORD $0xb5000089 // cbnz x9, LBB0_222 $16(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x9280000e // mov x14, #-1 + WORD $0x1400000b // b LBB0_223 $44(%rip) +LBB0_222: + WORD $0x8a390189 // bic x9, x12, x25 + WORD $0xaa09072a // orr x10, x25, x9, lsl #1 + WORD $0x8a2a018c // bic x12, x12, x10 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab090189 // adds x9, x12, x9 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff929 // lsl x9, x9, #1 + WORD $0xd200f129 // eor x9, x9, #0x5555555555555555 + WORD $0x8a0a0129 // and x9, x9, x10 + WORD $0xaa2903ee // mvn x14, x9 +LBB0_223: + WORD $0x6e208ed7 // cmeq.16b v23, v22, v0 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x6e208e99 // cmeq.16b v25, v20, v0 + WORD $0x4e211f39 // and.16b v25, v25, v1 + WORD $0x6e208e7a // cmeq.16b v26, v19, v0 + WORD $0x4e211f5a // and.16b v26, v26, v1 + WORD $0x4e02035a // tbl.16b v26, { v26 }, v2 + WORD $0x4e71bb5a // addv.8h h26, v26 + WORD $0x1e260349 // fmov w9, s26 + WORD $0xd3503d29 // lsl x9, x9, #48 + WORD $0x4e020339 // tbl.16b v25, { v25 }, v2 + WORD $0x4e71bb39 // addv.8h h25, v25 + WORD $0x1e26032a // fmov w10, s25 + WORD $0xb3603d49 // bfi x9, x10, #32, #16 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a0129 // orr x9, x9, x10 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0xaa0a0129 // orr x9, x9, x10 + WORD $0x8a0e0129 // and x9, x9, x14 + WORD $0x9200e12a // and x10, x9, #0x1111111111111111 + WORD $0x9203e12c // and x12, x9, #0x2222222222222222 + WORD $0x9202e12e // and x14, x9, #0x4444444444444444 + WORD $0x9201e129 // and x9, x9, #0x8888888888888888 + WORD $0xb200e3e6 // mov x6, #1229782938247303441 + WORD $0x9b067d4f // mul x15, x10, x6 + WORD $0x9b077d82 // mul x2, x12, x7 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b137dc2 // mul x2, x14, x19 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b147d22 // mul x2, x9, x20 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b147d42 // mul x2, x10, x20 + WORD $0x9b067d84 // mul x4, x12, x6 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b077dc4 // mul x4, x14, x7 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b137d24 // mul x4, x9, x19 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b137d44 // mul x4, x10, x19 + WORD $0x9b147d85 // mul x5, x12, x20 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b067dc5 // mul x5, x14, x6 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b077d25 // mul x5, x9, x7 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b077d4a // mul x10, x10, x7 + WORD $0x9b137d8c // mul x12, x12, x19 + WORD $0xca0c014a // eor x10, x10, x12 + WORD $0x9b147dcc // mul x12, x14, x20 + WORD $0xca0c014a // eor x10, x10, x12 + WORD $0x9b067d29 // mul x9, x9, x6 + WORD $0xca090149 // eor x9, x10, x9 + WORD $0x9200e1ea // and x10, x15, #0x1111111111111111 + WORD $0x9203e04c // and x12, x2, #0x2222222222222222 + WORD $0x9202e08e // and x14, x4, #0x4444444444444444 + WORD $0x9201e129 // and x9, x9, #0x8888888888888888 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa0e014a // orr x10, x10, x14 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0xca15012e // eor x14, x9, x21 + WORD $0x6e318ed7 // cmeq.16b v23, v22, v17 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e9 // fmov w9, s23 + WORD $0x6e318eb7 // cmeq.16b v23, v21, v17 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e318e97 // cmeq.16b v23, v20, v17 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x6e318e77 // cmeq.16b v23, v19, v17 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ef // fmov w15, s23 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503dec // bfi x12, x15, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0x8a2e012f // bic x15, x9, x14 + WORD $0x6e328ed6 // cmeq.16b v22, v22, v18 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c9 // fmov w9, s22 + WORD $0x6e328eb5 // cmeq.16b v21, v21, v18 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x6e328e94 // cmeq.16b v20, v20, v18 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x6e328e73 // cmeq.16b v19, v19, v18 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260262 // fmov w2, s19 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503c4c // bfi x12, x2, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0xea2e012c // bics x12, x9, x14 + WORD $0x54ffeaa0 // b.eq LBB0_218 $-684(%rip) +LBB0_224: + WORD $0xd1000595 // sub x21, x12, #1 + WORD $0x8a0f02a9 // and x9, x21, x15 + WORD $0x9e670133 // fmov d19, x9 + WORD $0x0e205a73 // cnt.8b v19, v19 + WORD $0x2e303a73 // uaddlv.8b h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x8b110129 // add x9, x9, x17 + WORD $0xeb18013f // cmp x9, x24 + WORD $0x54000729 // b.ls LBB0_242 $228(%rip) + WORD $0x91000718 // add x24, x24, #1 + WORD $0xea0c02ac // ands x12, x21, x12 + WORD $0x54fffea1 // b.ne LBB0_224 $-44(%rip) + WORD $0x17ffff48 // b LBB0_218 $-736(%rip) +LBB0_226: + WORD $0xf100035f // cmp x26, #0 + WORD $0x5400362d // b.le LBB0_316 $1732(%rip) + WORD $0xad0343f0 // stp q16, q16, [sp, #96] + WORD $0xad0243f0 // stp q16, q16, [sp, #64] + WORD $0x92402d09 // and x9, x8, #0xfff + WORD $0xf13f053f // cmp x9, #4033 + WORD $0x54ffe963 // b.lo LBB0_220 $-724(%rip) + WORD $0xf100834f // subs x15, x26, #32 + WORD $0x54000103 // b.lo LBB0_230 $32(%rip) + WORD $0x3dc00113 // ldr q19, [x8] + WORD $0x3d8013f3 // str q19, [sp, #64] + WORD $0x3dc00513 // ldr q19, [x8, #16] + WORD $0x3d8017f3 // str q19, [sp, #80] + WORD $0x91008108 // add x8, x8, #32 + WORD $0xf94017ee // ldr x14, [sp, #40] + WORD $0x14000003 // b LBB0_231 $12(%rip) +LBB0_230: + WORD $0x910103ee // add x14, sp, #64 + WORD $0xaa1a03ef // mov x15, x26 +LBB0_231: + WORD $0xf10041ec // subs x12, x15, #16 + WORD $0x54000243 // b.lo LBB0_237 $72(%rip) + WORD $0x3cc10513 // ldr q19, [x8], #16 + WORD $0x3c8105d3 // str q19, [x14], #16 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10021ec // subs x12, x15, #8 + WORD $0x540001e2 // b.hs LBB0_238 $60(%rip) +LBB0_233: + WORD $0xf10011ec // subs x12, x15, #4 + WORD $0x54000243 // b.lo LBB0_239 $72(%rip) +LBB0_234: + WORD $0xb8404509 // ldr w9, [x8], #4 + WORD $0xb80045c9 // str w9, [x14], #4 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10009ec // subs x12, x15, #2 + WORD $0x540001e2 // b.hs LBB0_240 $60(%rip) +LBB0_235: + WORD $0xb400024f // cbz x15, LBB0_241 $72(%rip) +LBB0_236: + WORD $0x39400108 // ldrb w8, [x8] + WORD $0x390001c8 // strb w8, [x14] + WORD $0x910103e8 // add x8, sp, #64 + WORD $0x17ffff2d // b LBB0_220 $-844(%rip) +LBB0_237: + WORD $0xf10021ec // subs x12, x15, #8 + WORD $0x54fffe63 // b.lo LBB0_233 $-52(%rip) +LBB0_238: + WORD $0xf8408509 // ldr x9, [x8], #8 + WORD $0xf80085c9 // str x9, [x14], #8 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10011ec // subs x12, x15, #4 + WORD $0x54fffe02 // b.hs LBB0_234 $-64(%rip) +LBB0_239: + WORD $0xf10009ec // subs x12, x15, #2 + WORD $0x54fffe63 // b.lo LBB0_235 $-52(%rip) +LBB0_240: + WORD $0x78402509 // ldrh w9, [x8], #2 + WORD $0x780025c9 // strh w9, [x14], #2 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xb5fffe0f // cbnz x15, LBB0_236 $-64(%rip) +LBB0_241: + WORD $0x910103e8 // add x8, sp, #64 + WORD $0x17ffff1e // b LBB0_220 $-904(%rip) +LBB0_242: + WORD $0xf94001a8 // ldr x8, [x13] + WORD $0xdac00189 // rbit x9, x12 + WORD $0xdac01129 // clz x9, x9 + WORD $0xcb1a0129 // sub x9, x9, x26 + WORD $0x8b080128 // add x8, x9, x8 + WORD $0x91000509 // add x9, x8, #1 + WORD $0xf9000029 // str x9, [x1] + WORD $0xf94001aa // ldr x10, [x13] + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x9a888548 // csinc x8, x10, x8, hi + WORD $0x17fffd6b // b LBB0_149 $-2644(%rip) +LBB0_243: + WORD $0x5ac00328 // rbit w8, w25 + WORD $0x5ac01108 // clz w8, w8 + WORD $0x8b0801c8 // add x8, x14, x8 + WORD $0x8b110108 // add x8, x8, x17 + WORD $0x91000908 // add x8, x8, #2 + WORD $0x17fffd65 // b LBB0_149 $-2668(%rip) +LBB0_244: + WORD $0x8b0802e8 // add x8, x23, x8 + WORD $0xf10082cf // subs x15, x22, #32 + WORD $0x54002763 // b.lo LBB0_301 $1260(%rip) +LBB0_245: + WORD $0xad405113 // ldp q19, q20, [x8] + WORD $0x6e208e75 // cmeq.16b v21, v19, v0 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e238e73 // cmeq.16b v19, v19, v3 + WORD $0x6e238e94 // cmeq.16b v20, v20, v3 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602b6 // fmov w22, s21 + WORD $0x4e211ed5 // and.16b v21, v22, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602a9 // fmov w9, s21 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026c // fmov w12, s19 + WORD $0x4e211e93 // and.16b v19, v20, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026a // fmov w10, s19 + WORD $0x33103d36 // bfi w22, w9, #16, #16 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0x350021ac // cbnz w12, LBB0_298 $1076(%rip) + WORD $0xb500226e // cbnz x14, LBB0_299 $1100(%rip) + WORD $0xb40023f6 // cbz x22, LBB0_300 $1148(%rip) +LBB0_248: + WORD $0xdac002c9 // rbit x9, x22 + WORD $0xdac01129 // clz x9, x9 + WORD $0xcb170108 // sub x8, x8, x23 + WORD $0x8b090108 // add x8, x8, x9 + WORD $0x91000508 // add x8, x8, #1 + WORD $0xb6ff8968 // tbz x8, #63, LBB0_69 $-3796(%rip) + WORD $0x14000a2b // b LBB0_806 $10412(%rip) +LBB0_249: + WORD $0x9280002c // mov x12, #-2 + WORD $0x52800051 // mov w17, #2 + WORD $0x8b1101ce // add x14, x14, x17 + WORD $0x8b0f018f // add x15, x12, x15 + WORD $0xf10001ff // cmp x15, #0 + WORD $0x54ffa78d // b.le LBB0_150 $-2832(%rip) +LBB0_250: + WORD $0x394001cc // ldrb w12, [x14] + WORD $0x7101719f // cmp w12, #92 + WORD $0x54ffff00 // b.eq LBB0_249 $-32(%rip) + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000380 // b.eq LBB0_256 $112(%rip) + WORD $0x9280000c // mov x12, #-1 + WORD $0x52800031 // mov w17, #1 + WORD $0x8b1101ce // add x14, x14, x17 + WORD $0x8b0f018f // add x15, x12, x15 + WORD $0xf10001ff // cmp x15, #0 + WORD $0x54fffecc // b.gt LBB0_250 $-40(%rip) + WORD $0x17fffd30 // b LBB0_150 $-2880(%rip) +LBB0_253: + WORD $0xd280000e // mov x14, #0 + WORD $0x9280001c // mov x28, #-1 + WORD $0x92800015 // mov x21, #-1 + WORD $0xaa1a03e8 // mov x8, x26 + WORD $0xf10082cf // subs x15, x22, #32 + WORD $0x54fff902 // b.hs LBB0_245 $-224(%rip) + WORD $0x14000101 // b LBB0_301 $1028(%rip) +LBB0_254: + WORD $0xf90023ff // str xzr, [sp, #64] + WORD $0x8b0802e9 // add x9, x23, x8 + WORD $0xd100053b // sub x27, x9, #1 + WORD $0x8b190315 // add x21, x24, x25 + WORD $0xeb1b035f // cmp x26, x27 + WORD $0xfa413b28 // ccmp x25, #1, #8, lo + WORD $0x5400014a // b.ge LBB0_257 $40(%rip) +LBB0_255: + WORD $0xeb1b035f // cmp x26, x27 + WORD $0x1a9f17e9 // cset w9, eq + WORD $0xeb15031f // cmp x24, x21 + WORD $0x1a9f17ea // cset w10, eq + WORD $0x0a0a012e // and w14, w9, w10 + WORD $0x17fffc5e // b LBB0_82 $-3720(%rip) +LBB0_256: + WORD $0xcb1701c8 // sub x8, x14, x23 + WORD $0x91000508 // add x8, x8, #1 + WORD $0x17fffd18 // b LBB0_149 $-2976(%rip) +LBB0_257: + WORD $0x3201c3ea // mov w10, #-2139062144 +LBB0_258: + WORD $0x3940034c // ldrb w12, [x26] + WORD $0x7101719f // cmp w12, #92 + WORD $0x540001e1 // b.ne LBB0_263 $60(%rip) + WORD $0xcb1a0379 // sub x25, x27, x26 + WORD $0xf100073f // cmp x25, #1 + WORD $0x540140eb // b.lt LBB0_811 $10268(%rip) + WORD $0x39400749 // ldrb w9, [x26, #1] +Lloh2: + WORD $0x10015c0c // adr x12, __UnquoteTab $11136(%rip) +Lloh3: + WORD $0x9100018c // add x12, x12, __UnquoteTab@PAGEOFF $0(%rip) + WORD $0x3869698e // ldrb w14, [x12, x9] + WORD $0x7103fddf // cmp w14, #255 + WORD $0x54000180 // b.eq LBB0_265 $48(%rip) + WORD $0x34013f8e // cbz w14, LBB0_809 $10224(%rip) + WORD $0x390103ee // strb w14, [sp, #64] + WORD $0x91000b5a // add x26, x26, #2 + WORD $0x5280002c // mov w12, #1 + WORD $0x14000049 // b LBB0_274 $292(%rip) +LBB0_263: + WORD $0x39400309 // ldrb w9, [x24] + WORD $0x6b09019f // cmp w12, w9 + WORD $0x54ff84e1 // b.ne LBB0_76 $-3940(%rip) + WORD $0x9100075a // add x26, x26, #1 + WORD $0x91000718 // add x24, x24, #1 + WORD $0x1400005f // b LBB0_283 $380(%rip) +LBB0_265: + WORD $0xf100133f // cmp x25, #4 + WORD $0x54013e63 // b.lo LBB0_810 $10188(%rip) + WORD $0xaa1a03ec // mov x12, x26 + WORD $0xb8402d8e // ldr w14, [x12, #2]! + WORD $0x5299fa09 // mov w9, #53200 + WORD $0x72b9f9e9 // movk w9, #53199, lsl #16 + WORD $0x0b0901c9 // add w9, w14, w9 + WORD $0x0a2e014f // bic w15, w10, w14 + WORD $0x6a0901ff // tst w15, w9 + WORD $0x54013ca1 // b.ne LBB0_808 $10132(%rip) + WORD $0x52832329 // mov w9, #6425 + WORD $0x72a32329 // movk w9, #6425, lsl #16 + WORD $0x0b0901c9 // add w9, w14, w9 + WORD $0x2a0e0129 // orr w9, w9, w14 + WORD $0x3201c3e2 // mov w2, #-2139062144 + WORD $0x6a0a013f // tst w9, w10 + WORD $0x54013bc1 // b.ne LBB0_808 $10104(%rip) + WORD $0x3200dbe9 // mov w9, #2139062143 + WORD $0x0a0901d1 // and w17, w14, w9 + WORD $0x5288c8c9 // mov w9, #17990 + WORD $0x72a8c8c9 // movk w9, #17990, lsl #16 + WORD $0x0b090229 // add w9, w17, w9 + WORD $0x3202c7ea // mov w10, #-1061109568 + WORD $0x4b11014a // sub w10, w10, w17 + WORD $0x0a0a01ea // and w10, w15, w10 + WORD $0x6a09015f // tst w10, w9 + WORD $0x54013a81 // b.ne LBB0_808 $10064(%rip) + WORD $0x52872729 // mov w9, #14649 + WORD $0x72a72729 // movk w9, #14649, lsl #16 + WORD $0x0b090229 // add w9, w17, w9 + WORD $0x3203cbea // mov w10, #-522133280 + WORD $0x4b11014a // sub w10, w10, w17 + WORD $0x0a0a01ea // and w10, w15, w10 + WORD $0x6a09015f // tst w10, w9 + WORD $0x54013981 // b.ne LBB0_808 $10032(%rip) + WORD $0x5ac009c9 // rev w9, w14 + WORD $0x3200c3ea // mov w10, #16843009 + WORD $0x0a69114a // bic w10, w10, w9, lsr #4 + WORD $0x0b0a0d4a // add w10, w10, w10, lsl #3 + WORD $0x3200cfec // mov w12, #252645135 + WORD $0x0a0c0129 // and w9, w9, w12 + WORD $0x0b090149 // add w9, w10, w9 + WORD $0x2a49112c // orr w12, w9, w9, lsr #4 + WORD $0x53087d89 // lsr w9, w12, #8 + WORD $0x12181d2e // and w14, w9, #0xff00 + WORD $0xaa0e03ef // mov x15, x14 + WORD $0x33001d8f // bfxil w15, w12, #0, #8 + WORD $0x91001b56 // add x22, x26, #6 + WORD $0x7101fdff // cmp w15, #127 + WORD $0x54000649 // b.ls LBB0_285 $200(%rip) + WORD $0x711ffdff // cmp w15, #2047 + WORD $0x540006a9 // b.ls LBB0_286 $212(%rip) + WORD $0x514039e9 // sub w9, w15, #14, lsl #12 + WORD $0x3120053f // cmn w9, #2049 + WORD $0x54000788 // b.hi LBB0_287 $240(%rip) + WORD $0x530c7dc9 // lsr w9, w14, #12 + WORD $0x321b092e // orr w14, w9, #0xe0 + WORD $0x390103ee // strb w14, [sp, #64] + WORD $0x52801009 // mov w9, #128 + WORD $0x33062de9 // bfxil w9, w15, #6, #6 + WORD $0x390107e9 // strb w9, [sp, #65] + WORD $0x52801009 // mov w9, #128 + WORD $0x33001589 // bfxil w9, w12, #0, #6 + WORD $0x39010be9 // strb w9, [sp, #66] + WORD $0xaa1603fa // mov x26, x22 + WORD $0x5280006c // mov w12, #3 +LBB0_274: + WORD $0x910103f1 // add x17, sp, #64 + WORD $0xaa0c022f // orr x15, x17, x12 + WORD $0xeb15031f // cmp x24, x21 + WORD $0x540002c2 // b.hs LBB0_282 $88(%rip) + WORD $0xeb1101ff // cmp x15, x17 + WORD $0x54000289 // b.ls LBB0_282 $80(%rip) + WORD $0x39400309 // ldrb w9, [x24] + WORD $0x6b0e013f // cmp w9, w14 + WORD $0x54000201 // b.ne LBB0_281 $64(%rip) + WORD $0x9100070e // add x14, x24, #1 + WORD $0xf9401bec // ldr x12, [sp, #48] +LBB0_278: + WORD $0xaa0e03f8 // mov x24, x14 + WORD $0xaa0c03f1 // mov x17, x12 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x54000162 // b.hs LBB0_282 $44(%rip) + WORD $0xeb0f023f // cmp x17, x15 + WORD $0x54000122 // b.hs LBB0_282 $36(%rip) + WORD $0xaa1103ec // mov x12, x17 + WORD $0x38401589 // ldrb w9, [x12], #1 + WORD $0xaa1803ee // mov x14, x24 + WORD $0x384015ca // ldrb w10, [x14], #1 + WORD $0x6b09015f // cmp w10, w9 + WORD $0x54fffea0 // b.eq LBB0_278 $-44(%rip) + WORD $0x14000002 // b LBB0_282 $8(%rip) +LBB0_281: + WORD $0x910103f1 // add x17, sp, #64 +LBB0_282: + WORD $0xeb0f023f // cmp x17, x15 + WORD $0x3201c3ea // mov w10, #-2139062144 + WORD $0x54ff78c1 // b.ne LBB0_76 $-4328(%rip) +LBB0_283: + WORD $0xeb1b035f // cmp x26, x27 + WORD $0x54fff002 // b.hs LBB0_255 $-512(%rip) + WORD $0xeb15031f // cmp x24, x21 + WORD $0x54fff103 // b.lo LBB0_258 $-480(%rip) + WORD $0x17ffff7d // b LBB0_255 $-524(%rip) +LBB0_285: + WORD $0x12001d8e // and w14, w12, #0xff + WORD $0x390103ec // strb w12, [sp, #64] + WORD $0xaa1603fa // mov x26, x22 + WORD $0x5280002c // mov w12, #1 + WORD $0x17ffffdb // b LBB0_274 $-148(%rip) +LBB0_286: + WORD $0x53067de9 // lsr w9, w15, #6 + WORD $0x321a0529 // orr w9, w9, #0xc0 + WORD $0x12001d2e // and w14, w9, #0xff + WORD $0x390103e9 // strb w9, [sp, #64] + WORD $0x52801009 // mov w9, #128 + WORD $0x33001589 // bfxil w9, w12, #0, #6 + WORD $0x390107e9 // strb w9, [sp, #65] + WORD $0xaa1603fa // mov x26, x22 + WORD $0x5280004c // mov w12, #2 + WORD $0x17ffffd1 // b LBB0_274 $-188(%rip) +LBB0_287: + WORD $0x92800071 // mov x17, #-4 + WORD $0xf1001b3f // cmp x25, #6 + WORD $0x54013163 // b.lo LBB0_815 $9772(%rip) + WORD $0x530a7de9 // lsr w9, w15, #10 + WORD $0x7100d93f // cmp w9, #54 + WORD $0x54013108 // b.hi LBB0_815 $9760(%rip) + WORD $0x394002c9 // ldrb w9, [x22] + WORD $0x7101713f // cmp w9, #92 + WORD $0x54013041 // b.ne LBB0_814 $9736(%rip) + WORD $0x39401f49 // ldrb w9, [x26, #7] + WORD $0x7101d53f // cmp w9, #117 + WORD $0x54012fe1 // b.ne LBB0_814 $9724(%rip) + WORD $0xaa1a03ee // mov x14, x26 + WORD $0xb8408dcc // ldr w12, [x14, #8]! + WORD $0x5299fa09 // mov w9, #53200 + WORD $0x72b9f9e9 // movk w9, #53199, lsl #16 + WORD $0x0b090189 // add w9, w12, w9 + WORD $0x0a2c0051 // bic w17, w2, w12 + WORD $0x6a09023f // tst w17, w9 + WORD $0x54012e81 // b.ne LBB0_813 $9680(%rip) + WORD $0x52832329 // mov w9, #6425 + WORD $0x72a32329 // movk w9, #6425, lsl #16 + WORD $0x0b090189 // add w9, w12, w9 + WORD $0x2a0c0129 // orr w9, w9, w12 + WORD $0x6a02013f // tst w9, w2 + WORD $0x54012dc1 // b.ne LBB0_813 $9656(%rip) + WORD $0x3200dbe9 // mov w9, #2139062143 + WORD $0x0a090196 // and w22, w12, w9 + WORD $0x5288c8c9 // mov w9, #17990 + WORD $0x72a8c8c9 // movk w9, #17990, lsl #16 + WORD $0x0b0902c9 // add w9, w22, w9 + WORD $0x3202c7ea // mov w10, #-1061109568 + WORD $0x4b16014a // sub w10, w10, w22 + WORD $0x0a0a022a // and w10, w17, w10 + WORD $0x6a09015f // tst w10, w9 + WORD $0x54012c81 // b.ne LBB0_813 $9616(%rip) + WORD $0x52872729 // mov w9, #14649 + WORD $0x72a72729 // movk w9, #14649, lsl #16 + WORD $0x0b0902c9 // add w9, w22, w9 + WORD $0x3203cbea // mov w10, #-522133280 + WORD $0x4b16014a // sub w10, w10, w22 + WORD $0x0a0a022a // and w10, w17, w10 + WORD $0x6a09015f // tst w10, w9 + WORD $0x54012b81 // b.ne LBB0_813 $9584(%rip) + WORD $0x5ac00989 // rev w9, w12 + WORD $0x3200c3ea // mov w10, #16843009 + WORD $0x0a69114a // bic w10, w10, w9, lsr #4 + WORD $0x0b0a0d4a // add w10, w10, w10, lsl #3 + WORD $0x3200cfec // mov w12, #252645135 + WORD $0x0a0c0129 // and w9, w9, w12 + WORD $0x0b090149 // add w9, w10, w9 + WORD $0x2a491129 // orr w9, w9, w9, lsr #4 + WORD $0x53087d2a // lsr w10, w9, #8 + WORD $0x12181d4c // and w12, w10, #0xff00 + WORD $0x33001d2c // bfxil w12, w9, #0, #8 + WORD $0x51403989 // sub w9, w12, #14, lsl #12 + WORD $0x3110013f // cmn w9, #1024 + WORD $0x54012ac3 // b.lo LBB0_816 $9560(%rip) + WORD $0x0b0f2989 // add w9, w12, w15, lsl #10 + WORD $0x5284800a // mov w10, #9216 + WORD $0x72bf940a // movk w10, #64672, lsl #16 + WORD $0x0b0a012a // add w10, w9, w10 + WORD $0x53127d4c // lsr w12, w10, #18 + WORD $0x321c0d8c // orr w12, w12, #0xf0 + WORD $0x12001d8e // and w14, w12, #0xff + WORD $0x390103ec // strb w12, [sp, #64] + WORD $0x5280100c // mov w12, #128 + WORD $0x330c454c // bfxil w12, w10, #12, #6 + WORD $0x390107ec // strb w12, [sp, #65] + WORD $0x5280100c // mov w12, #128 + WORD $0x33062d4c // bfxil w12, w10, #6, #6 + WORD $0x39010bec // strb w12, [sp, #66] + WORD $0x5280100a // mov w10, #128 + WORD $0x3300152a // bfxil w10, w9, #0, #6 + WORD $0x39010fea // strb w10, [sp, #67] + WORD $0x9100335a // add x26, x26, #12 + WORD $0x5280008c // mov w12, #4 + WORD $0x17ffff83 // b LBB0_274 $-500(%rip) +LBB0_297: + WORD $0x8b0802ee // add x14, x23, x8 + WORD $0x17fffcd5 // b LBB0_189 $-3244(%rip) +LBB0_298: + WORD $0xdac00189 // rbit x9, x12 + WORD $0xdac01129 // clz x9, x9 + WORD $0xcb17010a // sub x10, x8, x23 + WORD $0x8b0a0129 // add x9, x9, x10 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a89139c // csel x28, x28, x9, ne + WORD $0x9a8912b5 // csel x21, x21, x9, ne +LBB0_299: + WORD $0x0a2e0189 // bic w9, w12, w14 + WORD $0x531f792a // lsl w10, w9, #1 + WORD $0x331f792e // bfi w14, w9, #1, #31 + WORD $0x0a2a018a // bic w10, w12, w10 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b090149 // adds w9, w10, w9 + WORD $0x3200f3ea // mov w10, #1431655765 + WORD $0x4a090549 // eor w9, w10, w9, lsl #1 + WORD $0x0a0e0129 // and w9, w9, w14 + WORD $0x1a9f37ee // cset w14, hs + WORD $0x2a2903e9 // mvn w9, w9 + WORD $0x8a160136 // and x22, x9, x22 + WORD $0xb5ffdc76 // cbnz x22, LBB0_248 $-1140(%rip) +LBB0_300: + WORD $0x91008108 // add x8, x8, #32 + WORD $0xaa0f03f6 // mov x22, x15 +LBB0_301: + WORD $0xb50004ce // cbnz x14, LBB0_314 $152(%rip) + WORD $0xb40003d6 // cbz x22, LBB0_311 $120(%rip) +LBB0_303: + WORD $0xcb1703ee // neg x14, x23 +LBB0_304: + WORD $0xd280000f // mov x15, #0 +LBB0_305: + WORD $0x386f690c // ldrb w12, [x8, x15] + WORD $0x7100899f // cmp w12, #34 + WORD $0x540002e0 // b.eq LBB0_310 $92(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_308 $20(%rip) + WORD $0x910005ef // add x15, x15, #1 + WORD $0xeb0f02df // cmp x22, x15 + WORD $0x54ffff21 // b.ne LBB0_305 $-28(%rip) + WORD $0x14000016 // b LBB0_312 $88(%rip) +LBB0_308: + WORD $0xd10006c9 // sub x9, x22, #1 + WORD $0xeb0f013f // cmp x9, x15 + WORD $0x54012040 // b.eq LBB0_806 $9224(%rip) + WORD $0x8b0801c9 // add x9, x14, x8 + WORD $0x8b0f0129 // add x9, x9, x15 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a9c013c // csel x28, x9, x28, eq + WORD $0x9a950135 // csel x21, x9, x21, eq + WORD $0x8b0f0108 // add x8, x8, x15 + WORD $0x91000908 // add x8, x8, #2 + WORD $0xcb0f02c9 // sub x9, x22, x15 + WORD $0xd1000aca // sub x10, x22, #2 + WORD $0xd1000936 // sub x22, x9, #2 + WORD $0xeb0f015f // cmp x10, x15 + WORD $0x54fffd01 // b.ne LBB0_304 $-96(%rip) + WORD $0x140008f5 // b LBB0_806 $9172(%rip) +LBB0_310: + WORD $0x8b0f0108 // add x8, x8, x15 + WORD $0x91000508 // add x8, x8, #1 +LBB0_311: + WORD $0xcb170108 // sub x8, x8, x23 + WORD $0xb6ff6208 // tbz x8, #63, LBB0_69 $-5056(%rip) + WORD $0x140008f0 // b LBB0_806 $9152(%rip) +LBB0_312: + WORD $0x7100899f // cmp w12, #34 + WORD $0x54011dc1 // b.ne LBB0_806 $9144(%rip) + WORD $0x8b160108 // add x8, x8, x22 + WORD $0x17fffffa // b LBB0_311 $-24(%rip) +LBB0_314: + WORD $0xb4011d76 // cbz x22, LBB0_806 $9132(%rip) + WORD $0xaa3703e9 // mvn x9, x23 + WORD $0x8b090109 // add x9, x8, x9 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a9c013c // csel x28, x9, x28, eq + WORD $0x9a950135 // csel x21, x9, x21, eq + WORD $0x91000508 // add x8, x8, #1 + WORD $0xd10006d6 // sub x22, x22, #1 + WORD $0xb5fffa96 // cbnz x22, LBB0_303 $-176(%rip) + WORD $0x17fffff0 // b LBB0_311 $-64(%rip) +LBB0_316: + WORD $0xf94001a8 // ldr x8, [x13] + WORD $0x17fffbf6 // b LBB0_149 $-4136(%rip) +LBB0_317: + WORD $0xd10006a9 // sub x9, x21, #1 + WORD $0xeb11013f // cmp x9, x17 + WORD $0x54ff7e80 // b.eq LBB0_150 $-4144(%rip) + WORD $0x8b0e02e9 // add x9, x23, x14 + WORD $0x8b110129 // add x9, x9, x17 + WORD $0x9100092e // add x14, x9, #2 + WORD $0xcb1102a9 // sub x9, x21, x17 + WORD $0xd100092f // sub x15, x9, #2 + WORD $0x17fffc84 // b LBB0_189 $-3568(%rip) +LBB0_319: + WORD $0x71016d9f // cmp w12, #91 + WORD $0x54010d01 // b.ne LBB0_772 $8608(%rip) + WORD $0xf940056c // ldr x12, [x11, #8] + WORD $0xf9400191 // ldr x17, [x12] + WORD $0xb7f90f51 // tbnz x17, #63, LBB0_780 $8680(%rip) + WORD $0xf94001ae // ldr x14, [x13] + WORD $0xeb0e011f // cmp x8, x14 + WORD $0x54000162 // b.hs LBB0_326 $44(%rip) + WORD $0x38686aec // ldrb w12, [x23, x8] + WORD $0x7100359f // cmp w12, #13 + WORD $0x54000100 // b.eq LBB0_326 $32(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x540000c0 // b.eq LBB0_326 $24(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000062 // b.hs LBB0_326 $12(%rip) + WORD $0xaa0803f5 // mov x21, x8 + WORD $0x14000037 // b LBB0_347 $220(%rip) +LBB0_326: + WORD $0x91000515 // add x21, x8, #1 + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54000122 // b.hs LBB0_330 $36(%rip) + WORD $0x38756aec // ldrb w12, [x23, x21] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_330 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_330 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000583 // b.lo LBB0_347 $176(%rip) +LBB0_330: + WORD $0x91000915 // add x21, x8, #2 + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54000122 // b.hs LBB0_334 $36(%rip) + WORD $0x38756aec // ldrb w12, [x23, x21] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_334 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_334 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000423 // b.lo LBB0_347 $132(%rip) +LBB0_334: + WORD $0x91000d15 // add x21, x8, #3 + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54000122 // b.hs LBB0_338 $36(%rip) + WORD $0x38756aec // ldrb w12, [x23, x21] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_338 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_338 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x540002c3 // b.lo LBB0_347 $88(%rip) +LBB0_338: + WORD $0x91001115 // add x21, x8, #4 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x540001a9 // b.ls LBB0_343 $52(%rip) + WORD $0x540001c0 // b.eq LBB0_344 $56(%rip) + WORD $0x8b0e02ec // add x12, x23, x14 +LBB0_341: + WORD $0x38f56ae9 // ldrsb w9, [x23, x21] + WORD $0x7100813f // cmp w9, #32 + WORD $0x9ac92209 // lsl x9, x16, x9 + WORD $0x8a000129 // and x9, x9, x0 + WORD $0xfa409924 // ccmp x9, #0, #4, ls + WORD $0x54000120 // b.eq LBB0_346 $36(%rip) + WORD $0x910006b5 // add x21, x21, #1 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x54ffff01 // b.ne LBB0_341 $-32(%rip) + WORD $0x14000004 // b LBB0_345 $16(%rip) +LBB0_343: + WORD $0xaa1503e8 // mov x8, x21 + WORD $0x1400000a // b LBB0_348 $40(%rip) +LBB0_344: + WORD $0x8b1502ec // add x12, x23, x21 +LBB0_345: + WORD $0xcb170195 // sub x21, x12, x23 +LBB0_346: + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x540000c2 // b.hs LBB0_348 $24(%rip) +LBB0_347: + WORD $0x910006a8 // add x8, x21, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38756ae9 // ldrb w9, [x23, x21] + WORD $0x7101753f // cmp w9, #93 + WORD $0x540102e0 // b.eq LBB0_770 $8284(%rip) +LBB0_348: + WORD $0xd1000508 // sub x8, x8, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x14000007 // b LBB0_351 $28(%rip) +LBB0_349: + WORD $0xaa0803f5 // mov x21, x8 +LBB0_350: + WORD $0x910006a8 // add x8, x21, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38756aec // ldrb w12, [x23, x21] + WORD $0x7100b19f // cmp w12, #44 + WORD $0x54010181 // b.ne LBB0_769 $8240(%rip) +LBB0_351: + WORD $0xf1000631 // subs x17, x17, #1 + WORD $0x5400648b // b.lt LBB0_490 $3216(%rip) + WORD $0xf94001b5 // ldr x21, [x13] + WORD $0xeb15011f // cmp x8, x21 + WORD $0x54000162 // b.hs LBB0_357 $44(%rip) + WORD $0x38686aec // ldrb w12, [x23, x8] + WORD $0x7100359f // cmp w12, #13 + WORD $0x54000100 // b.eq LBB0_357 $32(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x540000c0 // b.eq LBB0_357 $24(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000062 // b.hs LBB0_357 $12(%rip) + WORD $0xaa0803ee // mov x14, x8 + WORD $0x14000035 // b LBB0_377 $212(%rip) +LBB0_357: + WORD $0x9100050e // add x14, x8, #1 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x54000122 // b.hs LBB0_361 $36(%rip) + WORD $0x386e6aec // ldrb w12, [x23, x14] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_361 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_361 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000543 // b.lo LBB0_377 $168(%rip) +LBB0_361: + WORD $0x9100090e // add x14, x8, #2 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x54000122 // b.hs LBB0_365 $36(%rip) + WORD $0x386e6aec // ldrb w12, [x23, x14] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_365 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_365 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x540003e3 // b.lo LBB0_377 $124(%rip) +LBB0_365: + WORD $0x91000d0e // add x14, x8, #3 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x54000122 // b.hs LBB0_369 $36(%rip) + WORD $0x386e6aec // ldrb w12, [x23, x14] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_369 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_369 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54000283 // b.lo LBB0_377 $80(%rip) +LBB0_369: + WORD $0x9100110e // add x14, x8, #4 + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54000809 // b.ls LBB0_390 $256(%rip) + WORD $0x54000180 // b.eq LBB0_374 $48(%rip) + WORD $0x8b1502ec // add x12, x23, x21 +LBB0_372: + WORD $0x38ee6ae9 // ldrsb w9, [x23, x14] + WORD $0x7100813f // cmp w9, #32 + WORD $0x9ac92209 // lsl x9, x16, x9 + WORD $0x8a000129 // and x9, x9, x0 + WORD $0xfa409924 // ccmp x9, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_376 $28(%rip) + WORD $0x910005ce // add x14, x14, #1 + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54ffff01 // b.ne LBB0_372 $-32(%rip) + WORD $0x14000002 // b LBB0_375 $8(%rip) +LBB0_374: + WORD $0x8b0e02ec // add x12, x23, x14 +LBB0_375: + WORD $0xcb17018e // sub x14, x12, x23 +LBB0_376: + WORD $0xeb1501df // cmp x14, x21 + WORD $0x540006e2 // b.hs LBB0_393 $220(%rip) +LBB0_377: + WORD $0x910005c8 // add x8, x14, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38ee6aec // ldrsb w12, [x23, x14] + WORD $0x7101ed9f // cmp w12, #123 + WORD $0x54000568 // b.hi LBB0_390 $172(%rip) +Lloh4: + WORD $0x10010a6f // adr x15, LJTI0_0 $8524(%rip) +Lloh5: + WORD $0x910001ef // add x15, x15, LJTI0_0@PAGEOFF $0(%rip) + WORD $0x10000089 // adr x9, LBB0_379 $16(%rip) + WORD $0x786c79ea // ldrh w10, [x15, x12, lsl #1] + WORD $0x8b0a0929 // add x9, x9, x10, lsl #2 + WORD $0xd61f0120 // br x9 +LBB0_379: + WORD $0xf94001a9 // ldr x9, [x13] + WORD $0xcb08012e // sub x14, x9, x8 + WORD $0xf10041df // cmp x14, #16 + WORD $0x540001e3 // b.lo LBB0_382 $60(%rip) +LBB0_380: + WORD $0x3ce86af3 // ldr q19, [x23, x8] + WORD $0x6e248e74 // cmeq.16b v20, v19, v4 + WORD $0x4e251e73 // and.16b v19, v19, v5 + WORD $0x6e268e73 // cmeq.16b v19, v19, v6 + WORD $0x4eb41e73 // orr.16b v19, v19, v20 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026c // fmov w12, s19 + WORD $0x3500034c // cbnz w12, LBB0_391 $104(%rip) + WORD $0xd10041ce // sub x14, x14, #16 + WORD $0x91004108 // add x8, x8, #16 + WORD $0xf1003ddf // cmp x14, #15 + WORD $0x54fffe68 // b.hi LBB0_380 $-52(%rip) +LBB0_382: + WORD $0x8b0802ef // add x15, x23, x8 + WORD $0xb40001ee // cbz x14, LBB0_389 $60(%rip) + WORD $0x8b0e01ec // add x12, x15, x14 + WORD $0xcb1701e8 // sub x8, x15, x23 +LBB0_384: + WORD $0x394001f5 // ldrb w21, [x15] + WORD $0x7100b2bf // cmp w21, #44 + WORD $0x54000240 // b.eq LBB0_392 $72(%rip) + WORD $0x7101f6bf // cmp w21, #125 + WORD $0x54000200 // b.eq LBB0_392 $64(%rip) + WORD $0x710176bf // cmp w21, #93 + WORD $0x540001c0 // b.eq LBB0_392 $56(%rip) + WORD $0x910005ef // add x15, x15, #1 + WORD $0x91000508 // add x8, x8, #1 + WORD $0xf10005ce // subs x14, x14, #1 + WORD $0x54fffec1 // b.ne LBB0_384 $-40(%rip) + WORD $0xaa0c03ef // mov x15, x12 +LBB0_389: + WORD $0xcb1701e8 // sub x8, x15, x23 + WORD $0x14000007 // b LBB0_392 $28(%rip) +LBB0_390: + WORD $0xf900002e // str x14, [x1] + WORD $0xaa0e03e8 // mov x8, x14 + WORD $0x14000005 // b LBB0_393 $20(%rip) +LBB0_391: + WORD $0x5ac00189 // rbit w9, w12 + WORD $0x5ac01129 // clz w9, w9 + WORD $0x8b080128 // add x8, x9, x8 +LBB0_392: + WORD $0xf9000028 // str x8, [x1] +LBB0_393: + WORD $0xa9403bd7 // ldp x23, x14, [x30] + WORD $0xeb0e011f // cmp x8, x14 + WORD $0x54000122 // b.hs LBB0_397 $36(%rip) + WORD $0x38686aec // ldrb w12, [x23, x8] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_397 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_397 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54ffeee3 // b.lo LBB0_349 $-548(%rip) +LBB0_397: + WORD $0x91000515 // add x21, x8, #1 + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54000122 // b.hs LBB0_401 $36(%rip) + WORD $0x38756aec // ldrb w12, [x23, x21] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_401 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_401 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54ffeda3 // b.lo LBB0_350 $-588(%rip) +LBB0_401: + WORD $0x91000915 // add x21, x8, #2 + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54000122 // b.hs LBB0_405 $36(%rip) + WORD $0x38756aec // ldrb w12, [x23, x21] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_405 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_405 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54ffec43 // b.lo LBB0_350 $-632(%rip) +LBB0_405: + WORD $0x91000d15 // add x21, x8, #3 + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54000122 // b.hs LBB0_409 $36(%rip) + WORD $0x38756aec // ldrb w12, [x23, x21] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_409 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_409 $16(%rip) + WORD $0x51002d89 // sub w9, w12, #11 + WORD $0x3100093f // cmn w9, #2 + WORD $0x54ffeae3 // b.lo LBB0_350 $-676(%rip) +LBB0_409: + WORD $0x91001115 // add x21, x8, #4 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x5400efc9 // b.ls LBB0_779 $7672(%rip) + WORD $0x54000180 // b.eq LBB0_414 $48(%rip) + WORD $0x8b0e02ec // add x12, x23, x14 +LBB0_412: + WORD $0x38f56ae9 // ldrsb w9, [x23, x21] + WORD $0x7100813f // cmp w9, #32 + WORD $0x9ac92209 // lsl x9, x16, x9 + WORD $0x8a000129 // and x9, x9, x0 + WORD $0xfa409924 // ccmp x9, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_416 $28(%rip) + WORD $0x910006b5 // add x21, x21, #1 + WORD $0xeb1501df // cmp x14, x21 + WORD $0x54ffff01 // b.ne LBB0_412 $-32(%rip) + WORD $0x14000002 // b LBB0_415 $8(%rip) +LBB0_414: + WORD $0x8b1502ec // add x12, x23, x21 +LBB0_415: + WORD $0xcb170195 // sub x21, x12, x23 +LBB0_416: + WORD $0xeb0e02bf // cmp x21, x14 + WORD $0x54ffe883 // b.lo LBB0_350 $-752(%rip) + WORD $0x1400075b // b LBB0_772 $7532(%rip) +LBB0_417: + WORD $0x910011cc // add x12, x14, #4 + WORD $0xf94001a9 // ldr x9, [x13] + WORD $0xeb09019f // cmp x12, x9 + WORD $0x54fff7a8 // b.hi LBB0_393 $-268(%rip) + WORD $0x14000045 // b LBB0_426 $276(%rip) +LBB0_418: + WORD $0xf94001ac // ldr x12, [x13] + WORD $0xcb08018f // sub x15, x12, x8 + WORD $0xf10081ff // cmp x15, #32 + WORD $0x54004aeb // b.lt LBB0_486 $2396(%rip) + WORD $0xd2800015 // mov x21, #0 + WORD $0xd2800019 // mov x25, #0 + WORD $0x8b0e02ef // add x15, x23, x14 + WORD $0xcb0e0196 // sub x22, x12, x14 + WORD $0x528003f8 // mov w24, #31 + WORD $0x14000008 // b LBB0_422 $32(%rip) +LBB0_420: + WORD $0xd2800019 // mov x25, #0 + WORD $0x350005fa // cbnz w26, LBB0_424 $188(%rip) +LBB0_421: + WORD $0x910082b5 // add x21, x21, #32 + WORD $0xd1008318 // sub x24, x24, #32 + WORD $0x8b1802c9 // add x9, x22, x24 + WORD $0xf100fd3f // cmp x9, #63 + WORD $0x5400458d // b.le LBB0_478 $2224(%rip) +LBB0_422: + WORD $0x8b1501e9 // add x9, x15, x21 + WORD $0x3cc01133 // ldur q19, [x9, #1] + WORD $0x3cc11134 // ldur q20, [x9, #17] + WORD $0x6e208e75 // cmeq.16b v21, v19, v0 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ba // fmov w26, s21 + WORD $0x6e208e95 // cmeq.16b v21, v20, v0 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602a9 // fmov w9, s21 + WORD $0x33103d3a // bfi w26, w9, #16, #16 + WORD $0x6e238e73 // cmeq.16b v19, v19, v3 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026c // fmov w12, s19 + WORD $0x6e238e93 // cmeq.16b v19, v20, v3 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x33103d2c // bfi w12, w9, #16, #16 + WORD $0x7100019f // cmp w12, #0 + WORD $0xfa400b20 // ccmp x25, #0, #0, eq + WORD $0x54fffbc0 // b.eq LBB0_420 $-136(%rip) + WORD $0x0a390189 // bic w9, w12, w25 + WORD $0x2a09072a // orr w10, w25, w9, lsl #1 + WORD $0x3201f3e2 // mov w2, #-1431655766 + WORD $0x0a02018c // and w12, w12, w2 + WORD $0x0a2a018c // bic w12, w12, w10 + WORD $0x2b090189 // adds w9, w12, w9 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a090589 // eor w9, w12, w9, lsl #1 + WORD $0x0a0a0129 // and w9, w9, w10 + WORD $0x2a2903e9 // mvn w9, w9 + WORD $0x8a1a013a // and x26, x9, x26 + WORD $0x34fffa7a // cbz w26, LBB0_421 $-180(%rip) +LBB0_424: + WORD $0x5ac00348 // rbit w8, w26 + WORD $0x5ac01108 // clz w8, w8 + WORD $0x8b0801c8 // add x8, x14, x8 + WORD $0x8b150108 // add x8, x8, x21 + WORD $0x91000908 // add x8, x8, #2 + WORD $0x17ffff7b // b LBB0_392 $-532(%rip) +LBB0_425: + WORD $0x910015cc // add x12, x14, #5 + WORD $0xf94001a9 // ldr x9, [x13] + WORD $0xeb09019f // cmp x12, x9 + WORD $0x54ffef08 // b.hi LBB0_393 $-544(%rip) +LBB0_426: + WORD $0xf900002c // str x12, [x1] + WORD $0xaa0c03e8 // mov x8, x12 + WORD $0x17ffff75 // b LBB0_393 $-556(%rip) +LBB0_427: + WORD $0xd2800015 // mov x21, #0 + WORD $0xd280001a // mov x26, #0 + WORD $0xd2800018 // mov x24, #0 + WORD $0xd2800019 // mov x25, #0 + WORD $0xf94001a9 // ldr x9, [x13] + WORD $0xcb08013b // sub x27, x9, x8 + WORD $0x8b0802e8 // add x8, x23, x8 + WORD $0x14000009 // b LBB0_429 $36(%rip) +LBB0_428: + WORD $0x937ffdd5 // asr x21, x14, #63 + WORD $0x9e6701f3 // fmov d19, x15 + WORD $0x0e205a73 // cnt.8b v19, v19 + WORD $0x2e303a73 // uaddlv.8b h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x8b180138 // add x24, x9, x24 + WORD $0x91010108 // add x8, x8, #64 + WORD $0xaa1703fb // mov x27, x23 +LBB0_429: + WORD $0xf1010377 // subs x23, x27, #64 + WORD $0x5400160b // b.lt LBB0_436 $704(%rip) +LBB0_430: + WORD $0xad405516 // ldp q22, q21, [x8] + WORD $0xad414d14 // ldp q20, q19, [x8, #32] + WORD $0x6e238ed7 // cmeq.16b v23, v22, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e9 // fmov w9, s23 + WORD $0x6e238eb7 // cmeq.16b v23, v21, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e238e97 // cmeq.16b v23, v20, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x6e238e77 // cmeq.16b v23, v19, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ee // fmov w14, s23 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503dcc // bfi x12, x14, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa09014c // orr x12, x10, x9 + WORD $0xaa1a0189 // orr x9, x12, x26 + WORD $0xb5000089 // cbnz x9, LBB0_432 $16(%rip) + WORD $0xd280001a // mov x26, #0 + WORD $0x9280000e // mov x14, #-1 + WORD $0x1400000b // b LBB0_433 $44(%rip) +LBB0_432: + WORD $0x8a3a0189 // bic x9, x12, x26 + WORD $0xaa09074a // orr x10, x26, x9, lsl #1 + WORD $0x8a2a018c // bic x12, x12, x10 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab090189 // adds x9, x12, x9 + WORD $0x1a9f37fa // cset w26, hs + WORD $0xd37ff929 // lsl x9, x9, #1 + WORD $0xd200f129 // eor x9, x9, #0x5555555555555555 + WORD $0x8a0a0129 // and x9, x9, x10 + WORD $0xaa2903ee // mvn x14, x9 +LBB0_433: + WORD $0x6e208ed7 // cmeq.16b v23, v22, v0 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x6e208e99 // cmeq.16b v25, v20, v0 + WORD $0x4e211f39 // and.16b v25, v25, v1 + WORD $0x6e208e7a // cmeq.16b v26, v19, v0 + WORD $0x4e211f5a // and.16b v26, v26, v1 + WORD $0x4e02035a // tbl.16b v26, { v26 }, v2 + WORD $0x4e71bb5a // addv.8h h26, v26 + WORD $0x1e260349 // fmov w9, s26 + WORD $0xd3503d29 // lsl x9, x9, #48 + WORD $0x4e020339 // tbl.16b v25, { v25 }, v2 + WORD $0x4e71bb39 // addv.8h h25, v25 + WORD $0x1e26032a // fmov w10, s25 + WORD $0xb3603d49 // bfi x9, x10, #32, #16 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a0129 // orr x9, x9, x10 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0xaa0a0129 // orr x9, x9, x10 + WORD $0x8a0e0129 // and x9, x9, x14 + WORD $0x9200e12a // and x10, x9, #0x1111111111111111 + WORD $0x9203e12c // and x12, x9, #0x2222222222222222 + WORD $0x9202e12e // and x14, x9, #0x4444444444444444 + WORD $0x9201e129 // and x9, x9, #0x8888888888888888 + WORD $0xb200e3e6 // mov x6, #1229782938247303441 + WORD $0x9b067d4f // mul x15, x10, x6 + WORD $0x9b077d82 // mul x2, x12, x7 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b137dc2 // mul x2, x14, x19 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b147d22 // mul x2, x9, x20 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b147d42 // mul x2, x10, x20 + WORD $0x9b067d84 // mul x4, x12, x6 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b077dc4 // mul x4, x14, x7 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b137d24 // mul x4, x9, x19 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b137d44 // mul x4, x10, x19 + WORD $0x9b147d85 // mul x5, x12, x20 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b067dc5 // mul x5, x14, x6 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b077d25 // mul x5, x9, x7 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b077d4a // mul x10, x10, x7 + WORD $0x9b137d8c // mul x12, x12, x19 + WORD $0xca0c014a // eor x10, x10, x12 + WORD $0x9b147dcc // mul x12, x14, x20 + WORD $0xca0c014a // eor x10, x10, x12 + WORD $0x9b067d29 // mul x9, x9, x6 + WORD $0xca090149 // eor x9, x10, x9 + WORD $0x9200e1ea // and x10, x15, #0x1111111111111111 + WORD $0x9203e04c // and x12, x2, #0x2222222222222222 + WORD $0x9202e08e // and x14, x4, #0x4444444444444444 + WORD $0x9201e129 // and x9, x9, #0x8888888888888888 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa0e014a // orr x10, x10, x14 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0xca15012e // eor x14, x9, x21 + WORD $0x6e318ed7 // cmeq.16b v23, v22, v17 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e9 // fmov w9, s23 + WORD $0x6e318eb7 // cmeq.16b v23, v21, v17 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e318e97 // cmeq.16b v23, v20, v17 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x6e318e77 // cmeq.16b v23, v19, v17 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ef // fmov w15, s23 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503dec // bfi x12, x15, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0x8a2e012f // bic x15, x9, x14 + WORD $0x6e328ed6 // cmeq.16b v22, v22, v18 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c9 // fmov w9, s22 + WORD $0x6e328eb5 // cmeq.16b v21, v21, v18 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x6e328e94 // cmeq.16b v20, v20, v18 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x6e328e73 // cmeq.16b v19, v19, v18 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260262 // fmov w2, s19 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503c4c // bfi x12, x2, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0xea2e012c // bics x12, x9, x14 + WORD $0x54ffeaa0 // b.eq LBB0_428 $-684(%rip) +LBB0_434: + WORD $0xd1000595 // sub x21, x12, #1 + WORD $0x8a0f02a9 // and x9, x21, x15 + WORD $0x9e670133 // fmov d19, x9 + WORD $0x0e205a73 // cnt.8b v19, v19 + WORD $0x2e303a73 // uaddlv.8b h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x8b180129 // add x9, x9, x24 + WORD $0xeb19013f // cmp x9, x25 + WORD $0x540025c9 // b.ls LBB0_477 $1208(%rip) + WORD $0x91000739 // add x25, x25, #1 + WORD $0xea0c02ac // ands x12, x21, x12 + WORD $0x54fffea1 // b.ne LBB0_434 $-44(%rip) + WORD $0x17ffff48 // b LBB0_428 $-736(%rip) +LBB0_436: + WORD $0xf100037f // cmp x27, #0 + WORD $0x54002a6d // b.le LBB0_487 $1356(%rip) + WORD $0xad0343f0 // stp q16, q16, [sp, #96] + WORD $0xad0243f0 // stp q16, q16, [sp, #64] + WORD $0x92402d09 // and x9, x8, #0xfff + WORD $0xf13f053f // cmp x9, #4033 + WORD $0x54ffe963 // b.lo LBB0_430 $-724(%rip) + WORD $0xf100836f // subs x15, x27, #32 + WORD $0x54000103 // b.lo LBB0_440 $32(%rip) + WORD $0x3dc00113 // ldr q19, [x8] + WORD $0x3d8013f3 // str q19, [sp, #64] + WORD $0x3dc00513 // ldr q19, [x8, #16] + WORD $0x3d8017f3 // str q19, [sp, #80] + WORD $0x91008108 // add x8, x8, #32 + WORD $0xf94017ee // ldr x14, [sp, #40] + WORD $0x14000003 // b LBB0_441 $12(%rip) +LBB0_440: + WORD $0x910103ee // add x14, sp, #64 + WORD $0xaa1b03ef // mov x15, x27 +LBB0_441: + WORD $0xf10041ec // subs x12, x15, #16 + WORD $0x54000243 // b.lo LBB0_447 $72(%rip) + WORD $0x3cc10513 // ldr q19, [x8], #16 + WORD $0x3c8105d3 // str q19, [x14], #16 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10021ec // subs x12, x15, #8 + WORD $0x540001e2 // b.hs LBB0_448 $60(%rip) +LBB0_443: + WORD $0xf10011ec // subs x12, x15, #4 + WORD $0x54000243 // b.lo LBB0_449 $72(%rip) +LBB0_444: + WORD $0xb8404509 // ldr w9, [x8], #4 + WORD $0xb80045c9 // str w9, [x14], #4 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10009ec // subs x12, x15, #2 + WORD $0x540001e2 // b.hs LBB0_450 $60(%rip) +LBB0_445: + WORD $0xb400024f // cbz x15, LBB0_451 $72(%rip) +LBB0_446: + WORD $0x39400108 // ldrb w8, [x8] + WORD $0x390001c8 // strb w8, [x14] + WORD $0x910103e8 // add x8, sp, #64 + WORD $0x17ffff2d // b LBB0_430 $-844(%rip) +LBB0_447: + WORD $0xf10021ec // subs x12, x15, #8 + WORD $0x54fffe63 // b.lo LBB0_443 $-52(%rip) +LBB0_448: + WORD $0xf8408509 // ldr x9, [x8], #8 + WORD $0xf80085c9 // str x9, [x14], #8 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10011ec // subs x12, x15, #4 + WORD $0x54fffe02 // b.hs LBB0_444 $-64(%rip) +LBB0_449: + WORD $0xf10009ec // subs x12, x15, #2 + WORD $0x54fffe63 // b.lo LBB0_445 $-52(%rip) +LBB0_450: + WORD $0x78402509 // ldrh w9, [x8], #2 + WORD $0x780025c9 // strh w9, [x14], #2 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xb5fffe0f // cbnz x15, LBB0_446 $-64(%rip) +LBB0_451: + WORD $0x910103e8 // add x8, sp, #64 + WORD $0x17ffff1e // b LBB0_430 $-904(%rip) +LBB0_452: + WORD $0xd2800015 // mov x21, #0 + WORD $0xd280001a // mov x26, #0 + WORD $0xd2800018 // mov x24, #0 + WORD $0xd2800019 // mov x25, #0 + WORD $0xf94001a9 // ldr x9, [x13] + WORD $0xcb08013b // sub x27, x9, x8 + WORD $0x8b0802e8 // add x8, x23, x8 + WORD $0x14000009 // b LBB0_454 $36(%rip) +LBB0_453: + WORD $0x937ffdd5 // asr x21, x14, #63 + WORD $0x9e6701f3 // fmov d19, x15 + WORD $0x0e205a73 // cnt.8b v19, v19 + WORD $0x2e303a73 // uaddlv.8b h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x8b180138 // add x24, x9, x24 + WORD $0x91010108 // add x8, x8, #64 + WORD $0xaa1703fb // mov x27, x23 +LBB0_454: + WORD $0xf1010377 // subs x23, x27, #64 + WORD $0x5400160b // b.lt LBB0_461 $704(%rip) +LBB0_455: + WORD $0xad405516 // ldp q22, q21, [x8] + WORD $0xad414d14 // ldp q20, q19, [x8, #32] + WORD $0x6e238ed7 // cmeq.16b v23, v22, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e9 // fmov w9, s23 + WORD $0x6e238eb7 // cmeq.16b v23, v21, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e238e97 // cmeq.16b v23, v20, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x6e238e77 // cmeq.16b v23, v19, v3 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ee // fmov w14, s23 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503dcc // bfi x12, x14, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa09014c // orr x12, x10, x9 + WORD $0xaa1a0189 // orr x9, x12, x26 + WORD $0xb5000089 // cbnz x9, LBB0_457 $16(%rip) + WORD $0xd280001a // mov x26, #0 + WORD $0x9280000e // mov x14, #-1 + WORD $0x1400000b // b LBB0_458 $44(%rip) +LBB0_457: + WORD $0x8a3a0189 // bic x9, x12, x26 + WORD $0xaa09074a // orr x10, x26, x9, lsl #1 + WORD $0x8a2a018c // bic x12, x12, x10 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab090189 // adds x9, x12, x9 + WORD $0x1a9f37fa // cset w26, hs + WORD $0xd37ff929 // lsl x9, x9, #1 + WORD $0xd200f129 // eor x9, x9, #0x5555555555555555 + WORD $0x8a0a0129 // and x9, x9, x10 + WORD $0xaa2903ee // mvn x14, x9 +LBB0_458: + WORD $0x6e208ed7 // cmeq.16b v23, v22, v0 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x6e208e99 // cmeq.16b v25, v20, v0 + WORD $0x4e211f39 // and.16b v25, v25, v1 + WORD $0x6e208e7a // cmeq.16b v26, v19, v0 + WORD $0x4e211f5a // and.16b v26, v26, v1 + WORD $0x4e02035a // tbl.16b v26, { v26 }, v2 + WORD $0x4e71bb5a // addv.8h h26, v26 + WORD $0x1e260349 // fmov w9, s26 + WORD $0xd3503d29 // lsl x9, x9, #48 + WORD $0x4e020339 // tbl.16b v25, { v25 }, v2 + WORD $0x4e71bb39 // addv.8h h25, v25 + WORD $0x1e26032a // fmov w10, s25 + WORD $0xb3603d49 // bfi x9, x10, #32, #16 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a0129 // orr x9, x9, x10 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0xaa0a0129 // orr x9, x9, x10 + WORD $0x8a0e0129 // and x9, x9, x14 + WORD $0x9200e12a // and x10, x9, #0x1111111111111111 + WORD $0x9203e12c // and x12, x9, #0x2222222222222222 + WORD $0x9202e12e // and x14, x9, #0x4444444444444444 + WORD $0x9201e129 // and x9, x9, #0x8888888888888888 + WORD $0xb200e3e6 // mov x6, #1229782938247303441 + WORD $0x9b067d4f // mul x15, x10, x6 + WORD $0x9b077d82 // mul x2, x12, x7 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b137dc2 // mul x2, x14, x19 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b147d22 // mul x2, x9, x20 + WORD $0xca0201ef // eor x15, x15, x2 + WORD $0x9b147d42 // mul x2, x10, x20 + WORD $0x9b067d84 // mul x4, x12, x6 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b077dc4 // mul x4, x14, x7 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b137d24 // mul x4, x9, x19 + WORD $0xca040042 // eor x2, x2, x4 + WORD $0x9b137d44 // mul x4, x10, x19 + WORD $0x9b147d85 // mul x5, x12, x20 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b067dc5 // mul x5, x14, x6 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b077d25 // mul x5, x9, x7 + WORD $0xca050084 // eor x4, x4, x5 + WORD $0x9b077d4a // mul x10, x10, x7 + WORD $0x9b137d8c // mul x12, x12, x19 + WORD $0xca0c014a // eor x10, x10, x12 + WORD $0x9b147dcc // mul x12, x14, x20 + WORD $0xca0c014a // eor x10, x10, x12 + WORD $0x9b067d29 // mul x9, x9, x6 + WORD $0xca090149 // eor x9, x10, x9 + WORD $0x9200e1ea // and x10, x15, #0x1111111111111111 + WORD $0x9203e04c // and x12, x2, #0x2222222222222222 + WORD $0x9202e08e // and x14, x4, #0x4444444444444444 + WORD $0x9201e129 // and x9, x9, #0x8888888888888888 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa0e014a // orr x10, x10, x14 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0xca15012e // eor x14, x9, x21 + WORD $0x6e278ed7 // cmeq.16b v23, v22, v7 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e9 // fmov w9, s23 + WORD $0x6e278eb7 // cmeq.16b v23, v21, v7 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e278e97 // cmeq.16b v23, v20, v7 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x6e278e77 // cmeq.16b v23, v19, v7 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ef // fmov w15, s23 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503dec // bfi x12, x15, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0x8a2e012f // bic x15, x9, x14 + WORD $0x6e268ed6 // cmeq.16b v22, v22, v6 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c9 // fmov w9, s22 + WORD $0x6e268eb5 // cmeq.16b v21, v21, v6 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x6e268e94 // cmeq.16b v20, v20, v6 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x6e268e73 // cmeq.16b v19, v19, v6 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e020273 // tbl.16b v19, { v19 }, v2 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260262 // fmov w2, s19 + WORD $0xd3607d8c // lsl x12, x12, #32 + WORD $0xb3503c4c // bfi x12, x2, #48, #16 + WORD $0x53103d4a // lsl w10, w10, #16 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xaa090149 // orr x9, x10, x9 + WORD $0xea2e012c // bics x12, x9, x14 + WORD $0x54ffeaa0 // b.eq LBB0_453 $-684(%rip) +LBB0_459: + WORD $0xd1000595 // sub x21, x12, #1 + WORD $0x8a0f02a9 // and x9, x21, x15 + WORD $0x9e670133 // fmov d19, x9 + WORD $0x0e205a73 // cnt.8b v19, v19 + WORD $0x2e303a73 // uaddlv.8b h19, v19 + WORD $0x1e260269 // fmov w9, s19 + WORD $0x8b180129 // add x9, x9, x24 + WORD $0xeb19013f // cmp x9, x25 + WORD $0x54000729 // b.ls LBB0_477 $228(%rip) + WORD $0x91000739 // add x25, x25, #1 + WORD $0xea0c02ac // ands x12, x21, x12 + WORD $0x54fffea1 // b.ne LBB0_459 $-44(%rip) + WORD $0x17ffff48 // b LBB0_453 $-736(%rip) +LBB0_461: + WORD $0xf100037f // cmp x27, #0 + WORD $0x54000bcd // b.le LBB0_487 $376(%rip) + WORD $0xad0343f0 // stp q16, q16, [sp, #96] + WORD $0xad0243f0 // stp q16, q16, [sp, #64] + WORD $0x92402d09 // and x9, x8, #0xfff + WORD $0xf13f053f // cmp x9, #4033 + WORD $0x54ffe963 // b.lo LBB0_455 $-724(%rip) + WORD $0xf100836f // subs x15, x27, #32 + WORD $0x54000103 // b.lo LBB0_465 $32(%rip) + WORD $0x3dc00113 // ldr q19, [x8] + WORD $0x3d8013f3 // str q19, [sp, #64] + WORD $0x3dc00513 // ldr q19, [x8, #16] + WORD $0x3d8017f3 // str q19, [sp, #80] + WORD $0x91008108 // add x8, x8, #32 + WORD $0xf94017ee // ldr x14, [sp, #40] + WORD $0x14000003 // b LBB0_466 $12(%rip) +LBB0_465: + WORD $0x910103ee // add x14, sp, #64 + WORD $0xaa1b03ef // mov x15, x27 +LBB0_466: + WORD $0xf10041ec // subs x12, x15, #16 + WORD $0x54000243 // b.lo LBB0_472 $72(%rip) + WORD $0x3cc10513 // ldr q19, [x8], #16 + WORD $0x3c8105d3 // str q19, [x14], #16 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10021ec // subs x12, x15, #8 + WORD $0x540001e2 // b.hs LBB0_473 $60(%rip) +LBB0_468: + WORD $0xf10011ec // subs x12, x15, #4 + WORD $0x54000243 // b.lo LBB0_474 $72(%rip) +LBB0_469: + WORD $0xb8404509 // ldr w9, [x8], #4 + WORD $0xb80045c9 // str w9, [x14], #4 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10009ec // subs x12, x15, #2 + WORD $0x540001e2 // b.hs LBB0_475 $60(%rip) +LBB0_470: + WORD $0xb400024f // cbz x15, LBB0_476 $72(%rip) +LBB0_471: + WORD $0x39400108 // ldrb w8, [x8] + WORD $0x390001c8 // strb w8, [x14] + WORD $0x910103e8 // add x8, sp, #64 + WORD $0x17ffff2d // b LBB0_455 $-844(%rip) +LBB0_472: + WORD $0xf10021ec // subs x12, x15, #8 + WORD $0x54fffe63 // b.lo LBB0_468 $-52(%rip) +LBB0_473: + WORD $0xf8408509 // ldr x9, [x8], #8 + WORD $0xf80085c9 // str x9, [x14], #8 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xf10011ec // subs x12, x15, #4 + WORD $0x54fffe02 // b.hs LBB0_469 $-64(%rip) +LBB0_474: + WORD $0xf10009ec // subs x12, x15, #2 + WORD $0x54fffe63 // b.lo LBB0_470 $-52(%rip) +LBB0_475: + WORD $0x78402509 // ldrh w9, [x8], #2 + WORD $0x780025c9 // strh w9, [x14], #2 + WORD $0xaa0c03ef // mov x15, x12 + WORD $0xb5fffe0f // cbnz x15, LBB0_471 $-64(%rip) +LBB0_476: + WORD $0x910103e8 // add x8, sp, #64 + WORD $0x17ffff1e // b LBB0_455 $-904(%rip) +LBB0_477: + WORD $0xf94001a8 // ldr x8, [x13] + WORD $0xdac00189 // rbit x9, x12 + WORD $0xdac01129 // clz x9, x9 + WORD $0xcb1b0129 // sub x9, x9, x27 + WORD $0x8b080128 // add x8, x9, x8 + WORD $0x91000509 // add x9, x8, #1 + WORD $0xf9000029 // str x9, [x1] + WORD $0xf94001aa // ldr x10, [x13] + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x9a888548 // csinc x8, x10, x8, hi + WORD $0x17fffd7f // b LBB0_392 $-2564(%rip) +LBB0_478: + WORD $0xb5000459 // cbnz x25, LBB0_488 $136(%rip) + WORD $0x8b0e02e9 // add x9, x23, x14 + WORD $0x8b150129 // add x9, x9, x21 + WORD $0x9100052e // add x14, x9, #1 + WORD $0xaa3503e9 // mvn x9, x21 + WORD $0x8b16012f // add x15, x9, x22 +LBB0_480: + WORD $0xf10005ff // cmp x15, #1 + WORD $0x5400010a // b.ge LBB0_482 $32(%rip) + WORD $0x17fffd77 // b LBB0_393 $-2596(%rip) +LBB0_481: + WORD $0x9280002c // mov x12, #-2 + WORD $0x52800055 // mov w21, #2 + WORD $0x8b1501ce // add x14, x14, x21 + WORD $0x8b0f018f // add x15, x12, x15 + WORD $0xf10001ff // cmp x15, #0 + WORD $0x54ffae2d // b.le LBB0_393 $-2620(%rip) +LBB0_482: + WORD $0x394001cc // ldrb w12, [x14] + WORD $0x7101719f // cmp w12, #92 + WORD $0x54ffff00 // b.eq LBB0_481 $-32(%rip) + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000100 // b.eq LBB0_485 $32(%rip) + WORD $0x9280000c // mov x12, #-1 + WORD $0x52800035 // mov w21, #1 + WORD $0x8b1501ce // add x14, x14, x21 + WORD $0x8b0f018f // add x15, x12, x15 + WORD $0xf10001ff // cmp x15, #0 + WORD $0x54fffecc // b.gt LBB0_482 $-40(%rip) + WORD $0x17fffd65 // b LBB0_393 $-2668(%rip) +LBB0_485: + WORD $0xcb1701c8 // sub x8, x14, x23 + WORD $0x91000508 // add x8, x8, #1 + WORD $0x17fffd61 // b LBB0_392 $-2684(%rip) +LBB0_486: + WORD $0x8b0802ee // add x14, x23, x8 + WORD $0x17ffffe7 // b LBB0_480 $-100(%rip) +LBB0_487: + WORD $0xf94001a8 // ldr x8, [x13] + WORD $0x17fffd5d // b LBB0_392 $-2700(%rip) +LBB0_488: + WORD $0xd10006c9 // sub x9, x22, #1 + WORD $0xeb15013f // cmp x9, x21 + WORD $0x54ffab60 // b.eq LBB0_393 $-2708(%rip) + WORD $0x8b0e02e9 // add x9, x23, x14 + WORD $0x8b150129 // add x9, x9, x21 + WORD $0x9100092e // add x14, x9, #2 + WORD $0xcb1502c9 // sub x9, x22, x21 + WORD $0xd100092f // sub x15, x9, #2 + WORD $0x17ffffdc // b LBB0_480 $-144(%rip) +LBB0_490: + WORD $0x9100416b // add x11, x11, #16 + WORD $0xaa0803ee // mov x14, x8 + WORD $0xf9401fe9 // ldr x9, [sp, #56] + WORD $0xeb09017f // cmp x11, x9 + WORD $0x10fec8c9 // adr x9, lCPI0_1 $-9960(%rip) + WORD $0x10fec82a // adr x10, lCPI0_0 $-9980(%rip) + WORD $0x54fece41 // b.ne LBB0_2 $-9784(%rip) + WORD $0x14000002 // b LBB0_492 $8(%rip) +LBB0_491: + WORD $0xf9400028 // ldr x8, [x1] +LBB0_492: +Lloh6: + WORD $0x10fec8ab // adr x11, lCPI0_2 $-9964(%rip) +Lloh7: + WORD $0x3dc00160 // ldr q0, [x11, lCPI0_2@PAGEOFF] $0(%rip) + WORD $0x3d800060 // str q0, [x3] + WORD $0xf94003cb // ldr x11, [x30] + WORD $0xaa2b03ec // mvn x12, x11 + WORD $0xf90013ec // str x12, [sp, #32] + WORD $0x5280002d // mov w13, #1 + WORD $0xcb0b01ac // sub x12, x13, x11 + WORD $0xf90017ec // str x12, [sp, #40] + WORD $0xcb0b03ec // neg x12, x11 + WORD $0xf9001bec // str x12, [sp, #48] + WORD $0xd100056c // sub x12, x11, #1 + WORD $0xf9001fec // str x12, [sp, #56] + WORD $0x92800014 // mov x20, #-1 + WORD $0xd284c002 // mov x2, #9728 + WORD $0xf2c00022 // movk x2, #1, lsl #32 + WORD $0x4f01e440 // movi.16b v0, #34 + WORD $0x4f02e781 // movi.16b v1, #92 + WORD $0x3dc00142 // ldr q2, [x10, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0xb27ff7e5 // mov x5, #9223372036854775806 + WORD $0x3dc00123 // ldr q3, [x9, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x4f01e5c4 // movi.16b v4, #46 + WORD $0x4f01e565 // movi.16b v5, #43 + WORD $0x12800009 // mov w9, #-1 +Lloh8: + WORD $0x1000c247 // adr x7, LJTI0_4 $6216(%rip) +Lloh9: + WORD $0x910000e7 // add x7, x7, LJTI0_4@PAGEOFF $0(%rip) + WORD $0x4f01e5a6 // movi.16b v6, #45 +Lloh10: + WORD $0x1000c2d3 // adr x19, LJTI0_5 $6232(%rip) +Lloh11: + WORD $0x91000273 // add x19, x19, LJTI0_5@PAGEOFF $0(%rip) + WORD $0x4f06e607 // movi.16b v7, #208 + WORD $0x4f00e550 // movi.16b v16, #10 + WORD $0x4f06e7f1 // movi.16b v17, #223 +Lloh12: + WORD $0x1000b938 // adr x24, LJTI0_2 $5924(%rip) +Lloh13: + WORD $0x91000318 // add x24, x24, LJTI0_2@PAGEOFF $0(%rip) + WORD $0x4f02e4b2 // movi.16b v18, #69 + WORD $0x52800035 // mov w21, #1 + WORD $0x14000009 // b LBB0_496 $36(%rip) +LBB0_493: + WORD $0x9100054c // add x12, x10, #1 + WORD $0xf900006c // str x12, [x3] + WORD $0x8b0a0c6a // add x10, x3, x10, lsl #3 + WORD $0x5280008c // mov w12, #4 +LBB0_494: + WORD $0xf900054c // str x12, [x10, #8] +LBB0_495: + WORD $0xf9400075 // ldr x21, [x3] + WORD $0xaa1403f1 // mov x17, x20 + WORD $0xb4009855 // cbz x21, LBB0_778 $4872(%rip) +LBB0_496: + WORD $0xf94007ca // ldr x10, [x30, #8] + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x54000162 // b.hs LBB0_501 $44(%rip) + WORD $0x3868696c // ldrb w12, [x11, x8] + WORD $0x7100359f // cmp w12, #13 + WORD $0x54000100 // b.eq LBB0_501 $32(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x540000c0 // b.eq LBB0_501 $24(%rip) + WORD $0x51002d8c // sub w12, w12, #11 + WORD $0x3100099f // cmn w12, #2 + WORD $0x54000062 // b.hs LBB0_501 $12(%rip) + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x14000035 // b LBB0_521 $212(%rip) +LBB0_501: + WORD $0x91000500 // add x0, x8, #1 + WORD $0xeb0a001f // cmp x0, x10 + WORD $0x54000122 // b.hs LBB0_505 $36(%rip) + WORD $0x3860696c // ldrb w12, [x11, x0] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_505 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_505 $16(%rip) + WORD $0x51002d8c // sub w12, w12, #11 + WORD $0x3100099f // cmn w12, #2 + WORD $0x54000543 // b.lo LBB0_521 $168(%rip) +LBB0_505: + WORD $0x91000900 // add x0, x8, #2 + WORD $0xeb0a001f // cmp x0, x10 + WORD $0x54000122 // b.hs LBB0_509 $36(%rip) + WORD $0x3860696c // ldrb w12, [x11, x0] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_509 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_509 $16(%rip) + WORD $0x51002d8c // sub w12, w12, #11 + WORD $0x3100099f // cmn w12, #2 + WORD $0x540003e3 // b.lo LBB0_521 $124(%rip) +LBB0_509: + WORD $0x91000d00 // add x0, x8, #3 + WORD $0xeb0a001f // cmp x0, x10 + WORD $0x54000122 // b.hs LBB0_513 $36(%rip) + WORD $0x3860696c // ldrb w12, [x11, x0] + WORD $0x7100359f // cmp w12, #13 + WORD $0x540000c0 // b.eq LBB0_513 $24(%rip) + WORD $0x7100819f // cmp w12, #32 + WORD $0x54000080 // b.eq LBB0_513 $16(%rip) + WORD $0x51002d8c // sub w12, w12, #11 + WORD $0x3100099f // cmn w12, #2 + WORD $0x54000283 // b.lo LBB0_521 $80(%rip) +LBB0_513: + WORD $0x91001100 // add x0, x8, #4 + WORD $0xeb00015f // cmp x10, x0 + WORD $0x540091e9 // b.ls LBB0_776 $4668(%rip) + WORD $0x54000180 // b.eq LBB0_518 $48(%rip) + WORD $0x8b0a0168 // add x8, x11, x10 +LBB0_516: + WORD $0x38e0696c // ldrsb w12, [x11, x0] + WORD $0x7100819f // cmp w12, #32 + WORD $0x9acc21ac // lsl x12, x13, x12 + WORD $0x8a02018c // and x12, x12, x2 + WORD $0xfa409984 // ccmp x12, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_520 $28(%rip) + WORD $0x91000400 // add x0, x0, #1 + WORD $0xeb00015f // cmp x10, x0 + WORD $0x54ffff01 // b.ne LBB0_516 $-32(%rip) + WORD $0x14000002 // b LBB0_519 $8(%rip) +LBB0_518: + WORD $0x8b000168 // add x8, x11, x0 +LBB0_519: + WORD $0xcb0b0100 // sub x0, x8, x11 +LBB0_520: + WORD $0xeb0a001f // cmp x0, x10 + WORD $0x54009002 // b.hs LBB0_777 $4608(%rip) +LBB0_521: + WORD $0x91000408 // add x8, x0, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x8b00017a // add x26, x11, x0 + WORD $0x39c00346 // ldrsb w6, [x26] + WORD $0x34008f66 // cbz w6, LBB0_777 $4588(%rip) + WORD $0xd10006aa // sub x10, x21, #1 + WORD $0x8b0a0c6c // add x12, x3, x10, lsl #3 + WORD $0xb8408d8e // ldr w14, [x12, #8]! + WORD $0xb100069f // cmn x20, #1 + WORD $0x9a940014 // csel x20, x0, x20, eq + WORD $0x510005ce // sub w14, w14, #1 + WORD $0x710015df // cmp w14, #5 + WORD $0x54000e48 // b.hi LBB0_541 $456(%rip) + WORD $0x1000008f // adr x15, LBB0_524 $16(%rip) + WORD $0x786e7b11 // ldrh w17, [x24, x14, lsl #1] + WORD $0x8b1109ef // add x15, x15, x17, lsl #2 + WORD $0xd61f01e0 // br x15 +LBB0_524: + WORD $0x7100b0df // cmp w6, #44 + WORD $0x54002280 // b.eq LBB0_583 $1104(%rip) + WORD $0x710174df // cmp w6, #93 + WORD $0x540021a0 // b.eq LBB0_582 $1076(%rip) + WORD $0x14000464 // b LBB0_774 $4496(%rip) +LBB0_526: + WORD $0x710088df // cmp w6, #34 + WORD $0x54008c41 // b.ne LBB0_774 $4488(%rip) + WORD $0x5280008a // mov w10, #4 + WORD $0xf900018a // str x10, [x12] + WORD $0xf94007d1 // ldr x17, [x30, #8] + WORD $0xeb080236 // subs x22, x17, x8 + WORD $0x54009960 // b.eq LBB0_807 $4908(%rip) + WORD $0xf10102df // cmp x22, #64 + WORD $0x54006ba3 // b.lo LBB0_712 $3444(%rip) + WORD $0xd2800017 // mov x23, #0 + WORD $0x9280000a // mov x10, #-1 + WORD $0x92800015 // mov x21, #-1 +LBB0_530: + WORD $0x8b08016c // add x12, x11, x8 + WORD $0xad405193 // ldp q19, q20, [x12] + WORD $0xad415995 // ldp q21, q22, [x12, #32] + WORD $0x6e208e77 // cmeq.16b v23, v19, v0 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e218e73 // cmeq.16b v19, v19, v1 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x4e221f17 // and.16b v23, v24, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ee // fmov w14, s23 + WORD $0x4e221f37 // and.16b v23, v25, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ef // fmov w15, s23 + WORD $0x4e221f57 // and.16b v23, v26, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e6 // fmov w6, s23 + WORD $0x4e221e73 // and.16b v19, v19, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260279 // fmov w25, s19 + WORD $0x4e221e93 // and.16b v19, v20, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26027a // fmov w26, s19 + WORD $0x4e221eb3 // and.16b v19, v21, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26027c // fmov w28, s19 + WORD $0x4e221ed3 // and.16b v19, v22, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26027b // fmov w27, s19 + WORD $0xd3607def // lsl x15, x15, #32 + WORD $0xb3503ccf // bfi x15, x6, #48, #16 + WORD $0x53103dce // lsl w14, w14, #16 + WORD $0xaa0e01ee // orr x14, x15, x14 + WORD $0xaa0c01c6 // orr x6, x14, x12 + WORD $0xd3607f8c // lsl x12, x28, #32 + WORD $0xb3503f6c // bfi x12, x27, #48, #16 + WORD $0x53103f4e // lsl w14, w26, #16 + WORD $0xaa0e018c // orr x12, x12, x14 + WORD $0xaa19018c // orr x12, x12, x25 + WORD $0xb500010c // cbnz x12, LBB0_534 $32(%rip) + WORD $0xb50001b7 // cbnz x23, LBB0_535 $52(%rip) + WORD $0xb50002e6 // cbnz x6, LBB0_536 $92(%rip) +LBB0_533: + WORD $0xd10102d6 // sub x22, x22, #64 + WORD $0x91010108 // add x8, x8, #64 + WORD $0xf100fedf // cmp x22, #63 + WORD $0x54fff8a8 // b.hi LBB0_530 $-236(%rip) + WORD $0x1400028d // b LBB0_685 $2612(%rip) +LBB0_534: + WORD $0xb10006bf // cmn x21, #1 + WORD $0xdac0018e // rbit x14, x12 + WORD $0xdac011ce // clz x14, x14 + WORD $0x8b0801ce // add x14, x14, x8 + WORD $0x9a8e114a // csel x10, x10, x14, ne + WORD $0x9a8e12b5 // csel x21, x21, x14, ne +LBB0_535: + WORD $0x8a37018e // bic x14, x12, x23 + WORD $0xaa0e06ef // orr x15, x23, x14, lsl #1 + WORD $0x8a2f018c // bic x12, x12, x15 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0e018c // adds x12, x12, x14 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0f018c // and x12, x12, x15 + WORD $0x8a2c00c6 // bic x6, x6, x12 + WORD $0xb4fffd66 // cbz x6, LBB0_533 $-84(%rip) +LBB0_536: + WORD $0xdac000cc // rbit x12, x6 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b080188 // add x8, x12, x8 + WORD $0x91000508 // add x8, x8, #1 +LBB0_537: + WORD $0xb7f883c8 // tbnz x8, #63, LBB0_782 $4216(%rip) +LBB0_538: + WORD $0xf9000028 // str x8, [x1] + WORD $0xaa0003f1 // mov x17, x0 + WORD $0xeb05001f // cmp x0, x5 + WORD $0x54ffe889 // b.ls LBB0_495 $-752(%rip) + WORD $0x14000407 // b LBB0_778 $4124(%rip) +LBB0_539: + WORD $0x710174df // cmp w6, #93 + WORD $0x540014c0 // b.eq LBB0_582 $664(%rip) + WORD $0xf900018d // str x13, [x12] + WORD $0x14000002 // b LBB0_542 $8(%rip) +LBB0_541: + WORD $0xf900006a // str x10, [x3] +LBB0_542: + WORD $0x7101ecdf // cmp w6, #123 + WORD $0x54007f28 // b.hi LBB0_774 $4068(%rip) + WORD $0x92800011 // mov x17, #-1 +Lloh14: + WORD $0x10009f8e // adr x14, LJTI0_3 $5104(%rip) +Lloh15: + WORD $0x910001ce // add x14, x14, LJTI0_3@PAGEOFF $0(%rip) + WORD $0x1000008a // adr x10, LBB0_544 $16(%rip) + WORD $0x786679cc // ldrh w12, [x14, x6, lsl #1] + WORD $0x8b0c094a // add x10, x10, x12, lsl #2 + WORD $0xd61f0140 // br x10 +LBB0_544: + WORD $0xf94007ca // ldr x10, [x30, #8] + WORD $0xeb000146 // subs x6, x10, x0 + WORD $0x540081e0 // b.eq LBB0_785 $4156(%rip) + WORD $0x3940034a // ldrb w10, [x26] + WORD $0x7100c15f // cmp w10, #48 + WORD $0x54000181 // b.ne LBB0_549 $48(%rip) + WORD $0xf10004df // cmp x6, #1 + WORD $0x54002340 // b.eq LBB0_611 $1128(%rip) + WORD $0x3868696a // ldrb w10, [x11, x8] + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x540022c8 // b.hi LBB0_611 $1112(%rip) + WORD $0x9aca21aa // lsl x10, x13, x10 + WORD $0xb20903ec // mov x12, #36028797027352576 + WORD $0xf280002c // movk x12, #1 + WORD $0xea0c015f // tst x10, x12 + WORD $0x54002220 // b.eq LBB0_611 $1092(%rip) +LBB0_549: + WORD $0xf10040df // cmp x6, #16 + WORD $0x54005d03 // b.lo LBB0_713 $2976(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x92800015 // mov x21, #-1 + WORD $0x92800011 // mov x17, #-1 + WORD $0x92800008 // mov x8, #-1 + WORD $0xaa0603f6 // mov x22, x6 +LBB0_551: + WORD $0x3cf96b53 // ldr q19, [x26, x25] + WORD $0x6e248e74 // cmeq.16b v20, v19, v4 + WORD $0x6e258e75 // cmeq.16b v21, v19, v5 + WORD $0x6e268e76 // cmeq.16b v22, v19, v6 + WORD $0x4e278677 // add.16b v23, v19, v7 + WORD $0x6e373617 // cmhi.16b v23, v16, v23 + WORD $0x4e311e73 // and.16b v19, v19, v17 + WORD $0x6e328e73 // cmeq.16b v19, v19, v18 + WORD $0x4eb51ed5 // orr.16b v21, v22, v21 + WORD $0x4eb41e76 // orr.16b v22, v19, v20 + WORD $0x4eb51ed6 // orr.16b v22, v22, v21 + WORD $0x4eb71ed6 // orr.16b v22, v22, v23 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x4e221e73 // and.16b v19, v19, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026e // fmov w14, s19 + WORD $0x4e221eb3 // and.16b v19, v21, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026f // fmov w15, s19 + WORD $0x4e221ed3 // and.16b v19, v22, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026a // fmov w10, s19 + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x32103d4a // orr w10, w10, #0xffff0000 + WORD $0x5ac0014a // rbit w10, w10 + WORD $0x5ac0114a // clz w10, w10 + WORD $0x1aca2137 // lsl w23, w9, w10 + WORD $0x0a37019b // bic w27, w12, w23 + WORD $0x0a3701dc // bic w28, w14, w23 + WORD $0x0a3701f7 // bic w23, w15, w23 + WORD $0x7100415f // cmp w10, #16 + WORD $0x1a9b018c // csel w12, w12, w27, eq + WORD $0x1a9c01dc // csel w28, w14, w28, eq + WORD $0x1a9701f7 // csel w23, w15, w23, eq + WORD $0x5100058e // sub w14, w12, #1 + WORD $0x6a0c01ce // ands w14, w14, w12 + WORD $0x54004881 // b.ne LBB0_690 $2320(%rip) + WORD $0x5100078e // sub w14, w28, #1 + WORD $0x6a1c01ce // ands w14, w14, w28 + WORD $0x54004821 // b.ne LBB0_690 $2308(%rip) + WORD $0x510006ee // sub w14, w23, #1 + WORD $0x6a1701ce // ands w14, w14, w23 + WORD $0x540047c1 // b.ne LBB0_690 $2296(%rip) + WORD $0x340000cc // cbz w12, LBB0_557 $24(%rip) + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb100051f // cmn x8, #1 + WORD $0x54004881 // b.ne LBB0_694 $2320(%rip) + WORD $0x8b0c0328 // add x8, x25, x12 +LBB0_557: + WORD $0x340000dc // cbz w28, LBB0_560 $24(%rip) + WORD $0x5ac0038c // rbit w12, w28 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb100063f // cmn x17, #1 + WORD $0x540047c1 // b.ne LBB0_694 $2296(%rip) + WORD $0x8b0c0331 // add x17, x25, x12 +LBB0_560: + WORD $0x340000d7 // cbz w23, LBB0_563 $24(%rip) + WORD $0x5ac002ec // rbit w12, w23 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x54004701 // b.ne LBB0_694 $2272(%rip) + WORD $0x8b0c0335 // add x21, x25, x12 +LBB0_563: + WORD $0x7100415f // cmp w10, #16 + WORD $0x540015c1 // b.ne LBB0_598 $696(%rip) + WORD $0xd10042d6 // sub x22, x22, #16 + WORD $0x91004339 // add x25, x25, #16 + WORD $0xf1003edf // cmp x22, #15 + WORD $0x54fff708 // b.hi LBB0_551 $-288(%rip) + WORD $0x8b190357 // add x23, x26, x25 + WORD $0xeb1900df // cmp x6, x25 + WORD $0x54001520 // b.eq LBB0_599 $676(%rip) +LBB0_566: + WORD $0x8b1602fc // add x28, x23, x22 + WORD $0xf9401fea // ldr x10, [sp, #56] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0xcb170146 // sub x6, x10, x23 + WORD $0xcb1a02f9 // sub x25, x23, x26 + WORD $0xaa1703ea // mov x10, x23 + WORD $0x1400000b // b LBB0_570 $44(%rip) +LBB0_567: + WORD $0x7101959f // cmp w12, #101 + WORD $0x54001401 // b.ne LBB0_599 $640(%rip) +LBB0_568: + WORD $0xb100063f // cmn x17, #1 + WORD $0xaa1903f1 // mov x17, x25 + WORD $0x54001601 // b.ne LBB0_609 $704(%rip) +LBB0_569: + WORD $0xd10004c6 // sub x6, x6, #1 + WORD $0x91000739 // add x25, x25, #1 + WORD $0xaa0a03f7 // mov x23, x10 + WORD $0xd10006d6 // sub x22, x22, #1 + WORD $0xb4002ad6 // cbz x22, LBB0_642 $1368(%rip) +LBB0_570: + WORD $0x38c0154c // ldrsb w12, [x10], #1 + WORD $0x5100c18e // sub w14, w12, #48 + WORD $0x710029df // cmp w14, #10 + WORD $0x54ffff03 // b.lo LBB0_569 $-32(%rip) + WORD $0x5100ad8e // sub w14, w12, #43 + WORD $0x710069df // cmp w14, #26 + WORD $0x54fffe08 // b.hi LBB0_567 $-64(%rip) + WORD $0x10fffe2c // adr x12, LBB0_568 $-60(%rip) + WORD $0x386e6a6f // ldrb w15, [x19, x14] + WORD $0x8b0f098c // add x12, x12, x15, lsl #2 + WORD $0xd61f0180 // br x12 +LBB0_573: + WORD $0xb10006bf // cmn x21, #1 + WORD $0xaa1903f5 // mov x21, x25 + WORD $0x54fffdc0 // b.eq LBB0_569 $-72(%rip) + WORD $0x1400009c // b LBB0_609 $624(%rip) +LBB0_574: + WORD $0xb100051f // cmn x8, #1 + WORD $0xaa1903e8 // mov x8, x25 + WORD $0x54fffd40 // b.eq LBB0_569 $-88(%rip) + WORD $0x14000098 // b LBB0_609 $608(%rip) +LBB0_575: + WORD $0x7100b0df // cmp w6, #44 + WORD $0x540001c1 // b.ne LBB0_581 $56(%rip) + WORD $0xf13ffebf // cmp x21, #4095 + WORD $0x54006fac // b.gt LBB0_781 $3572(%rip) + WORD $0x910006aa // add x10, x21, #1 + WORD $0xf900006a // str x10, [x3] + WORD $0x8b150c6a // add x10, x3, x21, lsl #3 + WORD $0x5280006c // mov w12, #3 + WORD $0x17fffea3 // b LBB0_494 $-1396(%rip) +LBB0_578: + WORD $0x7100e8df // cmp w6, #58 + WORD $0x54006be1 // b.ne LBB0_774 $3452(%rip) + WORD $0xf900019f // str xzr, [x12] + WORD $0x17fffea0 // b LBB0_495 $-1408(%rip) +LBB0_580: + WORD $0x710088df // cmp w6, #34 + WORD $0x540001e0 // b.eq LBB0_585 $60(%rip) +LBB0_581: + WORD $0x7101f4df // cmp w6, #125 + WORD $0x54006b21 // b.ne LBB0_774 $3428(%rip) +LBB0_582: + WORD $0xf900006a // str x10, [x3] + WORD $0xaa0a03f5 // mov x21, x10 + WORD $0xaa1403f1 // mov x17, x20 + WORD $0xb5ffd36a // cbnz x10, LBB0_496 $-1428(%rip) + WORD $0x1400035b // b LBB0_778 $3436(%rip) +LBB0_583: + WORD $0xf13ffebf // cmp x21, #4095 + WORD $0x54006d2c // b.gt LBB0_781 $3492(%rip) + WORD $0x910006aa // add x10, x21, #1 + WORD $0xf900006a // str x10, [x3] + WORD $0x8b150c6a // add x10, x3, x21, lsl #3 + WORD $0xf900055f // str xzr, [x10, #8] + WORD $0x17fffe90 // b LBB0_495 $-1472(%rip) +LBB0_585: + WORD $0x5280004a // mov w10, #2 + WORD $0xf900018a // str x10, [x12] + WORD $0xf94007d1 // ldr x17, [x30, #8] + WORD $0xeb080236 // subs x22, x17, x8 + WORD $0x540076c0 // b.eq LBB0_807 $3800(%rip) + WORD $0xf10102df // cmp x22, #64 + WORD $0x54004b03 // b.lo LBB0_715 $2400(%rip) + WORD $0xd2800017 // mov x23, #0 + WORD $0x9280000a // mov x10, #-1 + WORD $0x92800015 // mov x21, #-1 +LBB0_588: + WORD $0x8b08016c // add x12, x11, x8 + WORD $0xad405193 // ldp q19, q20, [x12] + WORD $0xad415995 // ldp q21, q22, [x12, #32] + WORD $0x6e208e77 // cmeq.16b v23, v19, v0 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e218e73 // cmeq.16b v19, v19, v1 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x4e221f17 // and.16b v23, v24, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ee // fmov w14, s23 + WORD $0x4e221f37 // and.16b v23, v25, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ef // fmov w15, s23 + WORD $0x4e221f57 // and.16b v23, v26, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602e6 // fmov w6, s23 + WORD $0x4e221e73 // and.16b v19, v19, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260279 // fmov w25, s19 + WORD $0x4e221e93 // and.16b v19, v20, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26027a // fmov w26, s19 + WORD $0x4e221eb3 // and.16b v19, v21, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26027b // fmov w27, s19 + WORD $0x4e221ed3 // and.16b v19, v22, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26027c // fmov w28, s19 + WORD $0xd3607def // lsl x15, x15, #32 + WORD $0xb3503ccf // bfi x15, x6, #48, #16 + WORD $0x53103dce // lsl w14, w14, #16 + WORD $0xaa0e01ee // orr x14, x15, x14 + WORD $0xaa0c01c6 // orr x6, x14, x12 + WORD $0xd3607f6c // lsl x12, x27, #32 + WORD $0xb3503f8c // bfi x12, x28, #48, #16 + WORD $0x53103f4e // lsl w14, w26, #16 + WORD $0xaa0e018c // orr x12, x12, x14 + WORD $0xaa19018c // orr x12, x12, x25 + WORD $0xb500010c // cbnz x12, LBB0_592 $32(%rip) + WORD $0xb50001b7 // cbnz x23, LBB0_593 $52(%rip) + WORD $0xb50002e6 // cbnz x6, LBB0_594 $92(%rip) +LBB0_591: + WORD $0xd10102d6 // sub x22, x22, #64 + WORD $0x91010108 // add x8, x8, #64 + WORD $0xf100fedf // cmp x22, #63 + WORD $0x54fff8a8 // b.hi LBB0_588 $-236(%rip) + WORD $0x140001a9 // b LBB0_695 $1700(%rip) +LBB0_592: + WORD $0xb10006bf // cmn x21, #1 + WORD $0xdac0018e // rbit x14, x12 + WORD $0xdac011ce // clz x14, x14 + WORD $0x8b0801ce // add x14, x14, x8 + WORD $0x9a8e114a // csel x10, x10, x14, ne + WORD $0x9a8e12b5 // csel x21, x21, x14, ne +LBB0_593: + WORD $0x8a37018e // bic x14, x12, x23 + WORD $0xaa0e06ef // orr x15, x23, x14, lsl #1 + WORD $0x8a2f018c // bic x12, x12, x15 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0e018c // adds x12, x12, x14 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0f018c // and x12, x12, x15 + WORD $0x8a2c00c6 // bic x6, x6, x12 + WORD $0xb4fffd66 // cbz x6, LBB0_591 $-84(%rip) +LBB0_594: + WORD $0xdac000cc // rbit x12, x6 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b080188 // add x8, x12, x8 + WORD $0x91000508 // add x8, x8, #1 +LBB0_595: + WORD $0xb7f86128 // tbnz x8, #63, LBB0_782 $3108(%rip) + WORD $0xf9000028 // str x8, [x1] + WORD $0xaa0003f1 // mov x17, x0 + WORD $0xeb05001f // cmp x0, x5 + WORD $0x54005e68 // b.hi LBB0_778 $3020(%rip) + WORD $0xf940006a // ldr x10, [x3] + WORD $0xf13ffd5f // cmp x10, #4095 + WORD $0x54ffc4ed // b.le LBB0_493 $-1892(%rip) + WORD $0x140002ff // b LBB0_781 $3068(%rip) +LBB0_598: + WORD $0x8b2a434a // add x10, x26, w10, uxtw + WORD $0x8b190157 // add x23, x10, x25 +LBB0_599: + WORD $0x92800006 // mov x6, #-1 + WORD $0xb40060a8 // cbz x8, LBB0_786 $3092(%rip) +LBB0_600: + WORD $0xb4006095 // cbz x21, LBB0_786 $3088(%rip) + WORD $0xb4006071 // cbz x17, LBB0_786 $3084(%rip) + WORD $0xcb1a02ea // sub x10, x23, x26 + WORD $0xd100054c // sub x12, x10, #1 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x54000160 // b.eq LBB0_608 $44(%rip) + WORD $0xeb0c02bf // cmp x21, x12 + WORD $0x54000120 // b.eq LBB0_608 $36(%rip) + WORD $0xeb0c023f // cmp x17, x12 + WORD $0x540000e0 // b.eq LBB0_608 $28(%rip) + WORD $0xf10006ac // subs x12, x21, #1 + WORD $0x5400018b // b.lt LBB0_612 $48(%rip) + WORD $0xeb0c023f // cmp x17, x12 + WORD $0x54000140 // b.eq LBB0_612 $40(%rip) + WORD $0xaa3503e6 // mvn x6, x21 + WORD $0x14000002 // b LBB0_609 $8(%rip) +LBB0_608: + WORD $0xcb0a03e6 // neg x6, x10 +LBB0_609: + WORD $0xb7f85e66 // tbnz x6, #63, LBB0_786 $3020(%rip) + WORD $0x8b0000c8 // add x8, x6, x0 +LBB0_611: + WORD $0xf9000028 // str x8, [x1] + WORD $0xaa0003f1 // mov x17, x0 + WORD $0xb6ffc220 // tbz x0, #63, LBB0_495 $-1980(%rip) + WORD $0x140002d4 // b LBB0_778 $2896(%rip) +LBB0_612: + WORD $0xaa11010c // orr x12, x8, x17 + WORD $0xb7f8138c // tbnz x12, #63, LBB0_641 $624(%rip) + WORD $0xeb11011f // cmp x8, x17 + WORD $0x5400134b // b.lt LBB0_641 $616(%rip) + WORD $0xaa2803e6 // mvn x6, x8 + WORD $0x17fffff5 // b LBB0_609 $-44(%rip) +LBB0_615: + WORD $0xf94007d1 // ldr x17, [x30, #8] + WORD $0xeb080236 // subs x22, x17, x8 + WORD $0x54006640 // b.eq LBB0_807 $3272(%rip) + WORD $0xf10102df // cmp x22, #64 + WORD $0x54003b63 // b.lo LBB0_716 $1900(%rip) + WORD $0xd2800017 // mov x23, #0 + WORD $0x9280000a // mov x10, #-1 + WORD $0x92800015 // mov x21, #-1 +LBB0_618: + WORD $0x8b08016c // add x12, x11, x8 + WORD $0xad405193 // ldp q19, q20, [x12] + WORD $0xad415995 // ldp q21, q22, [x12, #32] + WORD $0x6e208e77 // cmeq.16b v23, v19, v0 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e218e73 // cmeq.16b v19, v19, v1 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ec // fmov w12, s23 + WORD $0x4e221f17 // and.16b v23, v24, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ee // fmov w14, s23 + WORD $0x4e221f37 // and.16b v23, v25, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ef // fmov w15, s23 + WORD $0x4e221f57 // and.16b v23, v26, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602f0 // fmov w16, s23 + WORD $0x4e221e73 // and.16b v19, v19, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260264 // fmov w4, s19 + WORD $0x4e221e93 // and.16b v19, v20, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260279 // fmov w25, s19 + WORD $0x4e221eb3 // and.16b v19, v21, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26027a // fmov w26, s19 + WORD $0x4e221ed3 // and.16b v19, v22, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26027b // fmov w27, s19 + WORD $0xd3607def // lsl x15, x15, #32 + WORD $0xb3503e0f // bfi x15, x16, #48, #16 + WORD $0x53103dce // lsl w14, w14, #16 + WORD $0xaa0e01ee // orr x14, x15, x14 + WORD $0xaa0c01c6 // orr x6, x14, x12 + WORD $0xd3607f4c // lsl x12, x26, #32 + WORD $0xb3503f6c // bfi x12, x27, #48, #16 + WORD $0x53103f2e // lsl w14, w25, #16 + WORD $0xaa0e018c // orr x12, x12, x14 + WORD $0xaa04018c // orr x12, x12, x4 + WORD $0xb500010c // cbnz x12, LBB0_622 $32(%rip) + WORD $0xb50001b7 // cbnz x23, LBB0_623 $52(%rip) + WORD $0xb50002e6 // cbnz x6, LBB0_624 $92(%rip) +LBB0_621: + WORD $0xd10102d6 // sub x22, x22, #64 + WORD $0x91010108 // add x8, x8, #64 + WORD $0xf100fedf // cmp x22, #63 + WORD $0x54fff8a8 // b.hi LBB0_618 $-236(%rip) + WORD $0x1400015b // b LBB0_705 $1388(%rip) +LBB0_622: + WORD $0xb10006bf // cmn x21, #1 + WORD $0xdac0018e // rbit x14, x12 + WORD $0xdac011ce // clz x14, x14 + WORD $0x8b0801ce // add x14, x14, x8 + WORD $0x9a8e114a // csel x10, x10, x14, ne + WORD $0x9a8e12b5 // csel x21, x21, x14, ne +LBB0_623: + WORD $0x8a37018e // bic x14, x12, x23 + WORD $0xaa0e06ef // orr x15, x23, x14, lsl #1 + WORD $0x8a2f018c // bic x12, x12, x15 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0e018c // adds x12, x12, x14 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0f018c // and x12, x12, x15 + WORD $0x8a2c00c6 // bic x6, x6, x12 + WORD $0xb4fffd66 // cbz x6, LBB0_621 $-84(%rip) +LBB0_624: + WORD $0xdac000cc // rbit x12, x6 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b080188 // add x8, x12, x8 + WORD $0x91000508 // add x8, x8, #1 + WORD $0xb6ffcd08 // tbz x8, #63, LBB0_538 $-1632(%rip) + WORD $0x14000284 // b LBB0_782 $2576(%rip) +LBB0_625: + WORD $0xf94007ca // ldr x10, [x30, #8] + WORD $0xeb080159 // subs x25, x10, x8 + WORD $0x540051e0 // b.eq LBB0_788 $2620(%rip) + WORD $0x8b08016a // add x10, x11, x8 + WORD $0x3940014c // ldrb w12, [x10] + WORD $0x7100c19f // cmp w12, #48 + WORD $0x54000961 // b.ne LBB0_645 $300(%rip) + WORD $0xf100073f // cmp x25, #1 + WORD $0x540007e1 // b.ne LBB0_643 $252(%rip) +LBB0_628: + WORD $0x52800037 // mov w23, #1 + WORD $0x1400012e // b LBB0_702 $1208(%rip) +LBB0_629: + WORD $0xf940006a // ldr x10, [x3] + WORD $0xf13ffd5f // cmp x10, #4095 + WORD $0x54004e8c // b.gt LBB0_781 $2512(%rip) + WORD $0x9100054c // add x12, x10, #1 + WORD $0xf900006c // str x12, [x3] + WORD $0x8b0a0c6a // add x10, x3, x10, lsl #3 + WORD $0x528000ac // mov w12, #5 + WORD $0x17fffd9a // b LBB0_494 $-2456(%rip) +LBB0_631: + WORD $0xf94007ca // ldr x10, [x30, #8] + WORD $0xd100114c // sub x12, x10, #4 + WORD $0xeb0c001f // cmp x0, x12 + WORD $0x54004fc2 // b.hs LBB0_790 $2552(%rip) + WORD $0xb8686968 // ldr w8, [x11, x8] + WORD $0x528d8c2a // mov w10, #27745 + WORD $0x72acae6a // movk w10, #25971, lsl #16 + WORD $0x6b0a011f // cmp w8, w10 + WORD $0x54004f81 // b.ne LBB0_791 $2544(%rip) + WORD $0x91001408 // add x8, x0, #5 + WORD $0x17fffe49 // b LBB0_538 $-1756(%rip) +LBB0_634: + WORD $0xf94007c8 // ldr x8, [x30, #8] + WORD $0xd1000d0a // sub x10, x8, #3 + WORD $0xeb0a001f // cmp x0, x10 + WORD $0x54004da2 // b.hs LBB0_787 $2484(%rip) + WORD $0xb9400348 // ldr w8, [x26] + WORD $0x528eadca // mov w10, #30062 + WORD $0x72ad8d8a // movk w10, #27756, lsl #16 + WORD $0x6b0a011f // cmp w8, w10 + WORD $0x54000160 // b.eq LBB0_638 $44(%rip) + WORD $0x14000284 // b LBB0_796 $2576(%rip) +LBB0_636: + WORD $0xf94007c8 // ldr x8, [x30, #8] + WORD $0xd1000d0a // sub x10, x8, #3 + WORD $0xeb0a001f // cmp x0, x10 + WORD $0x54004c62 // b.hs LBB0_787 $2444(%rip) + WORD $0xb9400348 // ldr w8, [x26] + WORD $0x528e4e8a // mov w10, #29300 + WORD $0x72acaeaa // movk w10, #25973, lsl #16 + WORD $0x6b0a011f // cmp w8, w10 + WORD $0x540051e1 // b.ne LBB0_800 $2620(%rip) +LBB0_638: + WORD $0x91001008 // add x8, x0, #4 + WORD $0x17fffe34 // b LBB0_538 $-1840(%rip) +LBB0_639: + WORD $0xf940006a // ldr x10, [x3] + WORD $0xf13ffd5f // cmp x10, #4095 + WORD $0x5400498c // b.gt LBB0_781 $2352(%rip) + WORD $0x9100054c // add x12, x10, #1 + WORD $0xf900006c // str x12, [x3] + WORD $0x8b0a0c6a // add x10, x3, x10, lsl #3 + WORD $0x528000cc // mov w12, #6 + WORD $0x17fffd72 // b LBB0_494 $-2616(%rip) +LBB0_641: + WORD $0xd37ffd8c // lsr x12, x12, #63 + WORD $0x5200018c // eor w12, w12, #0x1 + WORD $0xd100062e // sub x14, x17, #1 + WORD $0xeb0e011f // cmp x8, x14 + WORD $0x1a9f17e8 // cset w8, eq + WORD $0x6a08019f // tst w12, w8 + WORD $0xda910146 // csinv x6, x10, x17, eq + WORD $0x17ffff56 // b LBB0_609 $-680(%rip) +LBB0_642: + WORD $0xaa1c03f7 // mov x23, x28 + WORD $0x92800006 // mov x6, #-1 + WORD $0xb5ffe848 // cbnz x8, LBB0_600 $-760(%rip) + WORD $0x14000245 // b LBB0_786 $2324(%rip) +LBB0_643: + WORD $0x3940054c // ldrb w12, [x10, #1] + WORD $0x5100b98c // sub w12, w12, #46 + WORD $0x7100dd9f // cmp w12, #55 + WORD $0x54fff7e8 // b.hi LBB0_628 $-260(%rip) + WORD $0x9acc21ac // lsl x12, x13, x12 + WORD $0x52800037 // mov w23, #1 + WORD $0xb20903ee // mov x14, #36028797027352576 + WORD $0xf280002e // movk x14, #1 + WORD $0xea0e019f // tst x12, x14 + WORD $0x54001d00 // b.eq LBB0_702 $928(%rip) +LBB0_645: + WORD $0xf100433f // cmp x25, #16 + WORD $0x54002703 // b.lo LBB0_717 $1248(%rip) + WORD $0xd280001a // mov x26, #0 + WORD $0x92800016 // mov x22, #-1 + WORD $0x92800015 // mov x21, #-1 + WORD $0x92800011 // mov x17, #-1 + WORD $0xaa1903f7 // mov x23, x25 +LBB0_647: + WORD $0x3cfa6953 // ldr q19, [x10, x26] + WORD $0x6e248e74 // cmeq.16b v20, v19, v4 + WORD $0x6e258e75 // cmeq.16b v21, v19, v5 + WORD $0x6e268e76 // cmeq.16b v22, v19, v6 + WORD $0x4e278677 // add.16b v23, v19, v7 + WORD $0x6e373617 // cmhi.16b v23, v16, v23 + WORD $0x4e311e73 // and.16b v19, v19, v17 + WORD $0x6e328e73 // cmeq.16b v19, v19, v18 + WORD $0x4eb51ed5 // orr.16b v21, v22, v21 + WORD $0x4eb41e76 // orr.16b v22, v19, v20 + WORD $0x4eb51ed6 // orr.16b v22, v22, v21 + WORD $0x4eb71ed6 // orr.16b v22, v22, v23 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x4e221e73 // and.16b v19, v19, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026f // fmov w15, s19 + WORD $0x4e221eb3 // and.16b v19, v21, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26027b // fmov w27, s19 + WORD $0x4e221ed3 // and.16b v19, v22, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026e // fmov w14, s19 + WORD $0x2a2e03ee // mvn w14, w14 + WORD $0x32103dce // orr w14, w14, #0xffff0000 + WORD $0x5ac001ce // rbit w14, w14 + WORD $0x5ac011c6 // clz w6, w14 + WORD $0x1ac6212e // lsl w14, w9, w6 + WORD $0x0a2e019c // bic w28, w12, w14 + WORD $0x0a2e01e4 // bic w4, w15, w14 + WORD $0x0a2e0370 // bic w16, w27, w14 + WORD $0x710040df // cmp w6, #16 + WORD $0x1a9c018e // csel w14, w12, w28, eq + WORD $0x1a8401ec // csel w12, w15, w4, eq + WORD $0x1a90037c // csel w28, w27, w16, eq + WORD $0x510005cf // sub w15, w14, #1 + WORD $0x6a0e01ef // ands w15, w15, w14 + WORD $0x54001781 // b.ne LBB0_704 $752(%rip) + WORD $0x5100058f // sub w15, w12, #1 + WORD $0x6a0c01ef // ands w15, w15, w12 + WORD $0x54001721 // b.ne LBB0_704 $740(%rip) + WORD $0x5100078f // sub w15, w28, #1 + WORD $0x6a1c01ef // ands w15, w15, w28 + WORD $0x540016c1 // b.ne LBB0_704 $728(%rip) + WORD $0x340000ce // cbz w14, LBB0_653 $24(%rip) + WORD $0x5ac001ce // rbit w14, w14 + WORD $0x5ac011ce // clz w14, w14 + WORD $0xb100063f // cmn x17, #1 + WORD $0x54001d81 // b.ne LBB0_714 $944(%rip) + WORD $0x8b0e0351 // add x17, x26, x14 +LBB0_653: + WORD $0x340000cc // cbz w12, LBB0_656 $24(%rip) + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x54001ac1 // b.ne LBB0_711 $856(%rip) + WORD $0x8b0c0355 // add x21, x26, x12 +LBB0_656: + WORD $0x340000dc // cbz w28, LBB0_659 $24(%rip) + WORD $0x5ac0038c // rbit w12, w28 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb10006df // cmn x22, #1 + WORD $0x54001a01 // b.ne LBB0_711 $832(%rip) + WORD $0x8b0c0356 // add x22, x26, x12 +LBB0_659: + WORD $0x710040df // cmp w6, #16 + WORD $0x54000541 // b.ne LBB0_674 $168(%rip) + WORD $0xd10042f7 // sub x23, x23, #16 + WORD $0x9100435a // add x26, x26, #16 + WORD $0xf1003eff // cmp x23, #15 + WORD $0x54fff708 // b.hi LBB0_647 $-288(%rip) + WORD $0x8b1a0146 // add x6, x10, x26 + WORD $0xeb1a033f // cmp x25, x26 + WORD $0x540004a0 // b.eq LBB0_675 $148(%rip) +LBB0_662: + WORD $0x8b1700d0 // add x16, x6, x23 + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b06018c // add x12, x12, x6 + WORD $0xcb000199 // sub x25, x12, x0 + WORD $0xaa0603fa // mov x26, x6 + WORD $0x14000008 // b LBB0_666 $32(%rip) +LBB0_663: + WORD $0xb10006df // cmn x22, #1 + WORD $0x54001781 // b.ne LBB0_710 $752(%rip) + WORD $0xd1000736 // sub x22, x25, #1 +LBB0_665: + WORD $0x91000739 // add x25, x25, #1 + WORD $0xaa1a03e6 // mov x6, x26 + WORD $0xd10006f7 // sub x23, x23, #1 + WORD $0xb4001157 // cbz x23, LBB0_703 $552(%rip) +LBB0_666: + WORD $0x38c0174c // ldrsb w12, [x26], #1 + WORD $0x5100c18e // sub w14, w12, #48 + WORD $0x710029df // cmp w14, #10 + WORD $0x54ffff23 // b.lo LBB0_665 $-28(%rip) + WORD $0x5100ad8e // sub w14, w12, #43 + WORD $0x710069df // cmp w14, #26 + WORD $0x54000128 // b.hi LBB0_671 $36(%rip) + WORD $0x10fffe4c // adr x12, LBB0_663 $-56(%rip) + WORD $0x386e68ef // ldrb w15, [x7, x14] + WORD $0x8b0f098c // add x12, x12, x15, lsl #2 + WORD $0xd61f0180 // br x12 +LBB0_669: + WORD $0xb100063f // cmn x17, #1 + WORD $0x54001541 // b.ne LBB0_710 $680(%rip) + WORD $0xd1000731 // sub x17, x25, #1 + WORD $0x17ffffee // b LBB0_665 $-72(%rip) +LBB0_671: + WORD $0x7101959f // cmp w12, #101 + WORD $0x540000e1 // b.ne LBB0_675 $28(%rip) +LBB0_672: + WORD $0xb10006bf // cmn x21, #1 + WORD $0x54001481 // b.ne LBB0_710 $656(%rip) + WORD $0xd1000735 // sub x21, x25, #1 + WORD $0x17ffffe8 // b LBB0_665 $-96(%rip) +LBB0_674: + WORD $0x8b26414c // add x12, x10, w6, uxtw + WORD $0x8b1a0186 // add x6, x12, x26 +LBB0_675: + WORD $0x92800017 // mov x23, #-1 + WORD $0xb4003931 // cbz x17, LBB0_789 $1828(%rip) +LBB0_676: + WORD $0xb4003916 // cbz x22, LBB0_789 $1824(%rip) + WORD $0xb40038f5 // cbz x21, LBB0_789 $1820(%rip) + WORD $0xcb0a00ca // sub x10, x6, x10 + WORD $0xd100054c // sub x12, x10, #1 + WORD $0xeb0c023f // cmp x17, x12 + WORD $0x54000160 // b.eq LBB0_684 $44(%rip) + WORD $0xeb0c02df // cmp x22, x12 + WORD $0x54000120 // b.eq LBB0_684 $36(%rip) + WORD $0xeb0c02bf // cmp x21, x12 + WORD $0x540000e0 // b.eq LBB0_684 $28(%rip) + WORD $0xf10006cc // subs x12, x22, #1 + WORD $0x540005eb // b.lt LBB0_691 $188(%rip) + WORD $0xeb0c02bf // cmp x21, x12 + WORD $0x540005a0 // b.eq LBB0_691 $180(%rip) + WORD $0xaa3603f7 // mvn x23, x22 + WORD $0x1400005e // b LBB0_701 $376(%rip) +LBB0_684: + WORD $0xcb0a03f7 // neg x23, x10 + WORD $0x1400005c // b LBB0_701 $368(%rip) +LBB0_685: + WORD $0x8b080168 // add x8, x11, x8 + WORD $0xf10082c6 // subs x6, x22, #32 + WORD $0x54001903 // b.lo LBB0_721 $800(%rip) +LBB0_686: + WORD $0xad405113 // ldp q19, q20, [x8] + WORD $0x6e208e75 // cmeq.16b v21, v19, v0 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e218e73 // cmeq.16b v19, v19, v1 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602b6 // fmov w22, s21 + WORD $0x4e221ed5 // and.16b v21, v22, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x4e221e73 // and.16b v19, v19, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260279 // fmov w25, s19 + WORD $0x4e221e93 // and.16b v19, v20, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026e // fmov w14, s19 + WORD $0x33103d96 // bfi w22, w12, #16, #16 + WORD $0x33103dd9 // bfi w25, w14, #16, #16 + WORD $0x35001359 // cbnz w25, LBB0_718 $616(%rip) + WORD $0xb5001417 // cbnz x23, LBB0_719 $640(%rip) + WORD $0xb4001596 // cbz x22, LBB0_720 $688(%rip) +LBB0_689: + WORD $0xdac002cc // rbit x12, x22 + WORD $0xdac0118c // clz x12, x12 + WORD $0xf94017ee // ldr x14, [sp, #40] + WORD $0x8b0801c8 // add x8, x14, x8 + WORD $0x8b0c0108 // add x8, x8, x12 + WORD $0x17fffd67 // b LBB0_537 $-2660(%rip) +LBB0_690: + WORD $0x5ac001c8 // rbit w8, w14 + WORD $0x5ac01108 // clz w8, w8 + WORD $0xaa3903ea // mvn x10, x25 + WORD $0xcb080146 // sub x6, x10, x8 + WORD $0x17fffe95 // b LBB0_609 $-1452(%rip) +LBB0_691: + WORD $0xaa15022c // orr x12, x17, x21 + WORD $0xb7f8056c // tbnz x12, #63, LBB0_700 $172(%rip) + WORD $0xeb15023f // cmp x17, x21 + WORD $0x5400052b // b.lt LBB0_700 $164(%rip) + WORD $0xaa3103f7 // mvn x23, x17 + WORD $0x1400002e // b LBB0_701 $184(%rip) +LBB0_694: + WORD $0xaa3903e8 // mvn x8, x25 + WORD $0xcb2c4106 // sub x6, x8, w12, uxtw + WORD $0x17fffe8c // b LBB0_609 $-1488(%rip) +LBB0_695: + WORD $0x8b080168 // add x8, x11, x8 + WORD $0xf10082c6 // subs x6, x22, #32 + WORD $0x54001a43 // b.lo LBB0_736 $840(%rip) +LBB0_696: + WORD $0xad405113 // ldp q19, q20, [x8] + WORD $0x6e208e75 // cmeq.16b v21, v19, v0 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e218e73 // cmeq.16b v19, v19, v1 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602b6 // fmov w22, s21 + WORD $0x4e221ed5 // and.16b v21, v22, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x4e221e73 // and.16b v19, v19, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260279 // fmov w25, s19 + WORD $0x4e221e93 // and.16b v19, v20, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026e // fmov w14, s19 + WORD $0x33103d96 // bfi w22, w12, #16, #16 + WORD $0x33103dd9 // bfi w25, w14, #16, #16 + WORD $0x35001499 // cbnz w25, LBB0_733 $656(%rip) + WORD $0xb5001557 // cbnz x23, LBB0_734 $680(%rip) + WORD $0xb40016d6 // cbz x22, LBB0_735 $728(%rip) +LBB0_699: + WORD $0xdac002cc // rbit x12, x22 + WORD $0xdac0118c // clz x12, x12 + WORD $0xf94017ee // ldr x14, [sp, #40] + WORD $0x8b0801c8 // add x8, x14, x8 + WORD $0x8b0c0108 // add x8, x8, x12 + WORD $0x17fffe4b // b LBB0_595 $-1748(%rip) +LBB0_700: + WORD $0xd37ffd8c // lsr x12, x12, #63 + WORD $0x5200018c // eor w12, w12, #0x1 + WORD $0xd10006ae // sub x14, x21, #1 + WORD $0xeb0e023f // cmp x17, x14 + WORD $0x1a9f17ee // cset w14, eq + WORD $0x6a0e019f // tst w12, w14 + WORD $0xda950157 // csinv x23, x10, x21, eq +LBB0_701: + WORD $0xb7f82b77 // tbnz x23, #63, LBB0_789 $1388(%rip) +LBB0_702: + WORD $0x8b0802e8 // add x8, x23, x8 + WORD $0x17fffd2d // b LBB0_538 $-2892(%rip) +LBB0_703: + WORD $0xaa1003e6 // mov x6, x16 + WORD $0x92800017 // mov x23, #-1 + WORD $0xb5fff1d1 // cbnz x17, LBB0_676 $-456(%rip) + WORD $0x14000155 // b LBB0_789 $1364(%rip) +LBB0_704: + WORD $0x5ac001ea // rbit w10, w15 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3a03ec // mvn x12, x26 + WORD $0xcb0a0197 // sub x23, x12, x10 + WORD $0x17fffff5 // b LBB0_701 $-44(%rip) +LBB0_705: + WORD $0x8b080168 // add x8, x11, x8 + WORD $0xf10082c6 // subs x6, x22, #32 + WORD $0x54001d63 // b.lo LBB0_755 $940(%rip) +LBB0_706: + WORD $0xad405113 // ldp q19, q20, [x8] + WORD $0x6e208e75 // cmeq.16b v21, v19, v0 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e218e73 // cmeq.16b v19, v19, v1 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602b6 // fmov w22, s21 + WORD $0x4e221ed5 // and.16b v21, v22, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x4e221e73 // and.16b v19, v19, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260279 // fmov w25, s19 + WORD $0x4e221e93 // and.16b v19, v20, v2 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e26026e // fmov w14, s19 + WORD $0x33103d96 // bfi w22, w12, #16, #16 + WORD $0x33103dd9 // bfi w25, w14, #16, #16 + WORD $0x350017b9 // cbnz w25, LBB0_752 $756(%rip) + WORD $0xb5001877 // cbnz x23, LBB0_753 $780(%rip) + WORD $0xb40019f6 // cbz x22, LBB0_754 $828(%rip) +LBB0_709: + WORD $0xdac002cc // rbit x12, x22 + WORD $0xdac0118c // clz x12, x12 + WORD $0xf94017ee // ldr x14, [sp, #40] + WORD $0x8b0801c8 // add x8, x14, x8 + WORD $0x8b0c0108 // add x8, x8, x12 + WORD $0xb6ffa028 // tbz x8, #63, LBB0_538 $-3068(%rip) + WORD $0x1400011d // b LBB0_782 $1140(%rip) +LBB0_710: + WORD $0xcb1903f7 // neg x23, x25 + WORD $0x17ffffcf // b LBB0_701 $-196(%rip) +LBB0_711: + WORD $0xaa3a03ea // mvn x10, x26 + WORD $0xcb2c4157 // sub x23, x10, w12, uxtw + WORD $0x17ffffcc // b LBB0_701 $-208(%rip) +LBB0_712: + WORD $0xd2800017 // mov x23, #0 + WORD $0x8b080168 // add x8, x11, x8 + WORD $0x9280000a // mov x10, #-1 + WORD $0x92800015 // mov x21, #-1 + WORD $0xf10082c6 // subs x6, x22, #32 + WORD $0x54ffedc2 // b.hs LBB0_686 $-584(%rip) + WORD $0x14000034 // b LBB0_721 $208(%rip) +LBB0_713: + WORD $0x92800008 // mov x8, #-1 + WORD $0xaa1a03f7 // mov x23, x26 + WORD $0xaa0603f6 // mov x22, x6 + WORD $0x92800011 // mov x17, #-1 + WORD $0x92800015 // mov x21, #-1 + WORD $0x17fffd65 // b LBB0_566 $-2668(%rip) +LBB0_714: + WORD $0xaa3a03ea // mvn x10, x26 + WORD $0xcb2e4157 // sub x23, x10, w14, uxtw + WORD $0x17ffffbc // b LBB0_701 $-272(%rip) +LBB0_715: + WORD $0xd2800017 // mov x23, #0 + WORD $0x8b080168 // add x8, x11, x8 + WORD $0x9280000a // mov x10, #-1 + WORD $0x92800015 // mov x21, #-1 + WORD $0xf10082c6 // subs x6, x22, #32 + WORD $0x54fff1e2 // b.hs LBB0_696 $-452(%rip) + WORD $0x1400005f // b LBB0_736 $380(%rip) +LBB0_716: + WORD $0xd2800017 // mov x23, #0 + WORD $0x8b080168 // add x8, x11, x8 + WORD $0x9280000a // mov x10, #-1 + WORD $0x92800015 // mov x21, #-1 + WORD $0xf10082c6 // subs x6, x22, #32 + WORD $0x54fff7c2 // b.hs LBB0_706 $-264(%rip) + WORD $0x140000a7 // b LBB0_755 $668(%rip) +LBB0_717: + WORD $0x92800011 // mov x17, #-1 + WORD $0xaa0a03e6 // mov x6, x10 + WORD $0xaa1903f7 // mov x23, x25 + WORD $0x92800015 // mov x21, #-1 + WORD $0x92800016 // mov x22, #-1 + WORD $0x17ffff15 // b LBB0_662 $-940(%rip) +LBB0_718: + WORD $0xdac0032c // rbit x12, x25 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb0b010e // sub x14, x8, x11 + WORD $0x8b0e018c // add x12, x12, x14 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a8c114a // csel x10, x10, x12, ne + WORD $0x9a8c12b5 // csel x21, x21, x12, ne +LBB0_719: + WORD $0x0a37032c // bic w12, w25, w23 + WORD $0x531f798e // lsl w14, w12, #1 + WORD $0x331f7997 // bfi w23, w12, #1, #31 + WORD $0x0a2e032e // bic w14, w25, w14 + WORD $0x1201f1ce // and w14, w14, #0xaaaaaaaa + WORD $0x2b0c01cc // adds w12, w14, w12 + WORD $0x3200f3ee // mov w14, #1431655765 + WORD $0x4a0c05cc // eor w12, w14, w12, lsl #1 + WORD $0x0a17018c // and w12, w12, w23 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0x2a2c03ec // mvn w12, w12 + WORD $0x8a160196 // and x22, x12, x22 + WORD $0xb5ffead6 // cbnz x22, LBB0_689 $-680(%rip) +LBB0_720: + WORD $0x91008108 // add x8, x8, #32 + WORD $0xaa0603f6 // mov x22, x6 +LBB0_721: + WORD $0xb5000c17 // cbnz x23, LBB0_748 $384(%rip) + WORD $0xb40003d6 // cbz x22, LBB0_730 $120(%rip) +LBB0_723: + WORD $0xd2800006 // mov x6, #0 +LBB0_724: + WORD $0x3866690c // ldrb w12, [x8, x6] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_729 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_727 $20(%rip) + WORD $0x910004c6 // add x6, x6, #1 + WORD $0xeb0602df // cmp x22, x6 + WORD $0x54ffff21 // b.ne LBB0_724 $-28(%rip) + WORD $0x14000016 // b LBB0_731 $88(%rip) +LBB0_727: + WORD $0xd10006cc // sub x12, x22, #1 + WORD $0xeb06019f // cmp x12, x6 + WORD $0x54001a20 // b.eq LBB0_783 $836(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b08018c // add x12, x12, x8 + WORD $0x8b06018c // add x12, x12, x6 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a8a018a // csel x10, x12, x10, eq + WORD $0x9a950195 // csel x21, x12, x21, eq + WORD $0x8b060108 // add x8, x8, x6 + WORD $0x91000908 // add x8, x8, #2 + WORD $0xcb0602cc // sub x12, x22, x6 + WORD $0xd1000ace // sub x14, x22, #2 + WORD $0xd1000996 // sub x22, x12, #2 + WORD $0xeb0601df // cmp x14, x6 + WORD $0x54fffce1 // b.ne LBB0_723 $-100(%rip) + WORD $0x140000c3 // b LBB0_783 $780(%rip) +LBB0_729: + WORD $0x8b060108 // add x8, x8, x6 + WORD $0x91000508 // add x8, x8, #1 +LBB0_730: + WORD $0xcb0b0108 // sub x8, x8, x11 + WORD $0x17fffc9f // b LBB0_537 $-3460(%rip) +LBB0_731: + WORD $0x7100899f // cmp w12, #34 + WORD $0x540017a1 // b.ne LBB0_783 $756(%rip) + WORD $0x8b160108 // add x8, x8, x22 + WORD $0x17fffffb // b LBB0_730 $-20(%rip) +LBB0_733: + WORD $0xdac0032c // rbit x12, x25 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb0b010e // sub x14, x8, x11 + WORD $0x8b0e018c // add x12, x12, x14 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a8c114a // csel x10, x10, x12, ne + WORD $0x9a8c12b5 // csel x21, x21, x12, ne +LBB0_734: + WORD $0x0a37032c // bic w12, w25, w23 + WORD $0x531f798e // lsl w14, w12, #1 + WORD $0x331f7997 // bfi w23, w12, #1, #31 + WORD $0x0a2e032e // bic w14, w25, w14 + WORD $0x1201f1ce // and w14, w14, #0xaaaaaaaa + WORD $0x2b0c01cc // adds w12, w14, w12 + WORD $0x3200f3ee // mov w14, #1431655765 + WORD $0x4a0c05cc // eor w12, w14, w12, lsl #1 + WORD $0x0a17018c // and w12, w12, w23 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0x2a2c03ec // mvn w12, w12 + WORD $0x8a160196 // and x22, x12, x22 + WORD $0xb5ffe996 // cbnz x22, LBB0_699 $-720(%rip) +LBB0_735: + WORD $0x91008108 // add x8, x8, #32 + WORD $0xaa0603f6 // mov x22, x6 +LBB0_736: + WORD $0xb50005f7 // cbnz x23, LBB0_750 $188(%rip) + WORD $0xb40003d6 // cbz x22, LBB0_745 $120(%rip) +LBB0_738: + WORD $0xd2800006 // mov x6, #0 +LBB0_739: + WORD $0x3866690c // ldrb w12, [x8, x6] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_744 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_742 $20(%rip) + WORD $0x910004c6 // add x6, x6, #1 + WORD $0xeb0602df // cmp x22, x6 + WORD $0x54ffff21 // b.ne LBB0_739 $-28(%rip) + WORD $0x14000016 // b LBB0_746 $88(%rip) +LBB0_742: + WORD $0xd10006cc // sub x12, x22, #1 + WORD $0xeb06019f // cmp x12, x6 + WORD $0x540012c0 // b.eq LBB0_783 $600(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b08018c // add x12, x12, x8 + WORD $0x8b06018c // add x12, x12, x6 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a8a018a // csel x10, x12, x10, eq + WORD $0x9a950195 // csel x21, x12, x21, eq + WORD $0x8b060108 // add x8, x8, x6 + WORD $0x91000908 // add x8, x8, #2 + WORD $0xcb0602cc // sub x12, x22, x6 + WORD $0xd1000ace // sub x14, x22, #2 + WORD $0xd1000996 // sub x22, x12, #2 + WORD $0xeb0601df // cmp x14, x6 + WORD $0x54fffce1 // b.ne LBB0_738 $-100(%rip) + WORD $0x14000088 // b LBB0_783 $544(%rip) +LBB0_744: + WORD $0x8b060108 // add x8, x8, x6 + WORD $0x91000508 // add x8, x8, #1 +LBB0_745: + WORD $0xcb0b0108 // sub x8, x8, x11 + WORD $0x17fffd79 // b LBB0_595 $-2588(%rip) +LBB0_746: + WORD $0x7100899f // cmp w12, #34 + WORD $0x54001041 // b.ne LBB0_783 $520(%rip) + WORD $0x8b160108 // add x8, x8, x22 + WORD $0x17fffffb // b LBB0_745 $-20(%rip) +LBB0_748: + WORD $0xb4000ff6 // cbz x22, LBB0_783 $508(%rip) + WORD $0xf94013ec // ldr x12, [sp, #32] + WORD $0x8b0c010c // add x12, x8, x12 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a8a018a // csel x10, x12, x10, eq + WORD $0x9a950195 // csel x21, x12, x21, eq + WORD $0x91000508 // add x8, x8, #1 + WORD $0xd10006d6 // sub x22, x22, #1 + WORD $0xb5fff356 // cbnz x22, LBB0_723 $-408(%rip) + WORD $0x17ffffb6 // b LBB0_730 $-296(%rip) +LBB0_750: + WORD $0xb4000eb6 // cbz x22, LBB0_783 $468(%rip) + WORD $0xf94013ec // ldr x12, [sp, #32] + WORD $0x8b0c010c // add x12, x8, x12 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a8a018a // csel x10, x12, x10, eq + WORD $0x9a950195 // csel x21, x12, x21, eq + WORD $0x91000508 // add x8, x8, #1 + WORD $0xd10006d6 // sub x22, x22, #1 + WORD $0xb5fff976 // cbnz x22, LBB0_738 $-212(%rip) + WORD $0x17ffffe7 // b LBB0_745 $-100(%rip) +LBB0_752: + WORD $0xdac0032c // rbit x12, x25 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb0b010e // sub x14, x8, x11 + WORD $0x8b0e018c // add x12, x12, x14 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a8c114a // csel x10, x10, x12, ne + WORD $0x9a8c12b5 // csel x21, x21, x12, ne +LBB0_753: + WORD $0x0a37032c // bic w12, w25, w23 + WORD $0x531f798e // lsl w14, w12, #1 + WORD $0x331f7997 // bfi w23, w12, #1, #31 + WORD $0x0a2e032e // bic w14, w25, w14 + WORD $0x1201f1ce // and w14, w14, #0xaaaaaaaa + WORD $0x2b0c01cc // adds w12, w14, w12 + WORD $0x3200f3ee // mov w14, #1431655765 + WORD $0x4a0c05cc // eor w12, w14, w12, lsl #1 + WORD $0x0a17018c // and w12, w12, w23 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0x2a2c03ec // mvn w12, w12 + WORD $0x8a160196 // and x22, x12, x22 + WORD $0xb5ffe676 // cbnz x22, LBB0_709 $-820(%rip) +LBB0_754: + WORD $0x91008108 // add x8, x8, #32 + WORD $0xaa0603f6 // mov x22, x6 +LBB0_755: + WORD $0xb50004d7 // cbnz x23, LBB0_767 $152(%rip) + WORD $0xb40003d6 // cbz x22, LBB0_764 $120(%rip) +LBB0_757: + WORD $0xd2800006 // mov x6, #0 +LBB0_758: + WORD $0x3866690c // ldrb w12, [x8, x6] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_763 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_761 $20(%rip) + WORD $0x910004c6 // add x6, x6, #1 + WORD $0xeb0602df // cmp x22, x6 + WORD $0x54ffff21 // b.ne LBB0_758 $-28(%rip) + WORD $0x14000017 // b LBB0_765 $92(%rip) +LBB0_761: + WORD $0xd10006cc // sub x12, x22, #1 + WORD $0xeb06019f // cmp x12, x6 + WORD $0x540008e0 // b.eq LBB0_783 $284(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b08018c // add x12, x12, x8 + WORD $0x8b06018c // add x12, x12, x6 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a8a018a // csel x10, x12, x10, eq + WORD $0x9a950195 // csel x21, x12, x21, eq + WORD $0x8b060108 // add x8, x8, x6 + WORD $0x91000908 // add x8, x8, #2 + WORD $0xcb0602cc // sub x12, x22, x6 + WORD $0xd1000ace // sub x14, x22, #2 + WORD $0xd1000996 // sub x22, x12, #2 + WORD $0xeb0601df // cmp x14, x6 + WORD $0x54fffce1 // b.ne LBB0_757 $-100(%rip) + WORD $0x14000039 // b LBB0_783 $228(%rip) +LBB0_763: + WORD $0x8b060108 // add x8, x8, x6 + WORD $0x91000508 // add x8, x8, #1 +LBB0_764: + WORD $0xcb0b0108 // sub x8, x8, x11 + WORD $0xb6ff82c8 // tbz x8, #63, LBB0_538 $-4008(%rip) + WORD $0x14000032 // b LBB0_782 $200(%rip) +LBB0_765: + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000641 // b.ne LBB0_783 $200(%rip) + WORD $0x8b160108 // add x8, x8, x22 + WORD $0x17fffffa // b LBB0_764 $-24(%rip) +LBB0_767: + WORD $0xb40005f6 // cbz x22, LBB0_783 $188(%rip) + WORD $0xf94013ec // ldr x12, [sp, #32] + WORD $0x8b0c010c // add x12, x8, x12 + WORD $0xb10006bf // cmn x21, #1 + WORD $0x9a8a018a // csel x10, x12, x10, eq + WORD $0x9a950195 // csel x21, x12, x21, eq + WORD $0x91000508 // add x8, x8, #1 + WORD $0xd10006d6 // sub x22, x22, #1 + WORD $0xb5fffa96 // cbnz x22, LBB0_757 $-176(%rip) + WORD $0x17fffff0 // b LBB0_764 $-64(%rip) +LBB0_769: + WORD $0x7101759f // cmp w12, #93 + WORD $0x540000e1 // b.ne LBB0_772 $28(%rip) +LBB0_770: + WORD $0xd1000508 // sub x8, x8, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x92800411 // mov x17, #-33 + WORD $0x1400000c // b LBB0_778 $48(%rip) +LBB0_771: + WORD $0x7101f59f // cmp w12, #125 + WORD $0x54ffff60 // b.eq LBB0_770 $-20(%rip) +LBB0_772: + WORD $0xd1000508 // sub x8, x8, #1 +LBB0_773: + WORD $0xf9000028 // str x8, [x1] +LBB0_774: + WORD $0x92800031 // mov x17, #-2 + WORD $0x14000006 // b LBB0_778 $24(%rip) +LBB0_775: + WORD $0xaa1103e8 // mov x8, x17 + WORD $0xd1000628 // sub x8, x17, #1 + WORD $0x17fffffb // b LBB0_773 $-20(%rip) +LBB0_776: + WORD $0xf9000020 // str x0, [x1] +LBB0_777: + WORD $0x92800011 // mov x17, #-1 +LBB0_778: + WORD $0xaa1103e0 // mov x0, x17 + WORD $0xa94d7bfd // ldp x29, x30, [sp, #208] + WORD $0xa94c4ff4 // ldp x20, x19, [sp, #192] + WORD $0xa94b57f6 // ldp x22, x21, [sp, #176] + WORD $0xa94a5ff8 // ldp x24, x23, [sp, #160] + WORD $0xa94967fa // ldp x26, x25, [sp, #144] + WORD $0xa9486ffc // ldp x28, x27, [sp, #128] + WORD $0x910383ff // add sp, sp, #224 + WORD $0xd65f03c0 // ret +LBB0_779: + WORD $0xaa1503e8 // mov x8, x21 + WORD $0xd10006a8 // sub x8, x21, #1 + WORD $0x17ffffed // b LBB0_773 $-76(%rip) +LBB0_780: + WORD $0xd1000508 // sub x8, x8, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x92800431 // mov x17, #-34 + WORD $0x17fffff1 // b LBB0_778 $-60(%rip) +LBB0_781: + WORD $0x928000d1 // mov x17, #-7 + WORD $0x17ffffef // b LBB0_778 $-68(%rip) +LBB0_782: + WORD $0xb100051f // cmn x8, #1 + WORD $0x54000061 // b.ne LBB0_784 $12(%rip) +LBB0_783: + WORD $0x92800008 // mov x8, #-1 + WORD $0xaa1103ea // mov x10, x17 +LBB0_784: + WORD $0xf900002a // str x10, [x1] + WORD $0xaa0803f1 // mov x17, x8 + WORD $0x17ffffe8 // b LBB0_778 $-96(%rip) +LBB0_785: + WORD $0x92800006 // mov x6, #-1 +LBB0_786: + WORD $0xaa2603e8 // mvn x8, x6 + WORD $0x8b080008 // add x8, x0, x8 + WORD $0x17ffffdc // b LBB0_773 $-144(%rip) +LBB0_787: + WORD $0xf9000028 // str x8, [x1] + WORD $0x92800011 // mov x17, #-1 + WORD $0x17ffffe1 // b LBB0_778 $-124(%rip) +LBB0_788: + WORD $0x92800017 // mov x23, #-1 +LBB0_789: + WORD $0xcb170008 // sub x8, x0, x23 + WORD $0x17ffffd6 // b LBB0_773 $-168(%rip) +LBB0_790: + WORD $0xf900002a // str x10, [x1] + WORD $0x92800011 // mov x17, #-1 + WORD $0x17ffffdb // b LBB0_778 $-148(%rip) +LBB0_791: + WORD $0x12001d08 // and w8, w8, #0xff + WORD $0x7101851f // cmp w8, #97 + WORD $0x54fffa21 // b.ne LBB0_774 $-188(%rip) + WORD $0x91000808 // add x8, x0, #2 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38686968 // ldrb w8, [x11, x8] + WORD $0x7101b11f // cmp w8, #108 + WORD $0x54fff981 // b.ne LBB0_774 $-208(%rip) + WORD $0x91000c08 // add x8, x0, #3 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38686968 // ldrb w8, [x11, x8] + WORD $0x7101cd1f // cmp w8, #115 + WORD $0x54fff8e1 // b.ne LBB0_774 $-228(%rip) + WORD $0x91001008 // add x8, x0, #4 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38686968 // ldrb w8, [x11, x8] + WORD $0x7101951f // cmp w8, #101 + WORD $0x54fff841 // b.ne LBB0_774 $-248(%rip) + WORD $0x91001408 // add x8, x0, #5 + WORD $0x17ffffbf // b LBB0_773 $-260(%rip) +LBB0_796: + WORD $0xf9000020 // str x0, [x1] + WORD $0x39400348 // ldrb w8, [x26] + WORD $0x7101b91f // cmp w8, #110 + WORD $0x54fff781 // b.ne LBB0_774 $-272(%rip) + WORD $0x91000408 // add x8, x0, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38686968 // ldrb w8, [x11, x8] + WORD $0x7101d51f // cmp w8, #117 + WORD $0x54fff6e1 // b.ne LBB0_774 $-292(%rip) + WORD $0x91000808 // add x8, x0, #2 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38686968 // ldrb w8, [x11, x8] + WORD $0x7101b11f // cmp w8, #108 + WORD $0x54fff641 // b.ne LBB0_774 $-312(%rip) + WORD $0x91000c08 // add x8, x0, #3 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38686968 // ldrb w8, [x11, x8] + WORD $0x7101b11f // cmp w8, #108 + WORD $0x54fff5a1 // b.ne LBB0_774 $-332(%rip) + WORD $0x14000014 // b LBB0_804 $80(%rip) +LBB0_800: + WORD $0xf9000020 // str x0, [x1] + WORD $0x39400348 // ldrb w8, [x26] + WORD $0x7101d11f // cmp w8, #116 + WORD $0x54fff501 // b.ne LBB0_774 $-352(%rip) + WORD $0x91000408 // add x8, x0, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38686968 // ldrb w8, [x11, x8] + WORD $0x7101c91f // cmp w8, #114 + WORD $0x54fff461 // b.ne LBB0_774 $-372(%rip) + WORD $0x91000808 // add x8, x0, #2 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38686968 // ldrb w8, [x11, x8] + WORD $0x7101d51f // cmp w8, #117 + WORD $0x54fff3c1 // b.ne LBB0_774 $-392(%rip) + WORD $0x91000c08 // add x8, x0, #3 + WORD $0xf9000028 // str x8, [x1] + WORD $0x38686968 // ldrb w8, [x11, x8] + WORD $0x7101951f // cmp w8, #101 + WORD $0x54fff321 // b.ne LBB0_774 $-412(%rip) +LBB0_804: + WORD $0x91001008 // add x8, x0, #4 + WORD $0x17ffff96 // b LBB0_773 $-424(%rip) +LBB0_805: + WORD $0xaa0803fb // mov x27, x8 +LBB0_806: + WORD $0xf900003b // str x27, [x1] + WORD $0x92800011 // mov x17, #-1 + WORD $0x17ffff9a // b LBB0_778 $-408(%rip) +LBB0_807: + WORD $0xaa0803f1 // mov x17, x8 + WORD $0x17ffffac // b LBB0_783 $-336(%rip) +LBB0_808: + WORD $0x92800031 // mov x17, #-2 + WORD $0xaa0c03fa // mov x26, x12 + WORD $0x14000006 // b LBB0_812 $24(%rip) +LBB0_809: + WORD $0x9100075a // add x26, x26, #1 + WORD $0x92800051 // mov x17, #-3 + WORD $0x14000003 // b LBB0_812 $12(%rip) +LBB0_810: + WORD $0x9100075a // add x26, x26, #1 +LBB0_811: + WORD $0x92800011 // mov x17, #-1 +LBB0_812: + WORD $0xcb170348 // sub x8, x26, x23 + WORD $0xf9000028 // str x8, [x1] + WORD $0x17ffff8d // b LBB0_778 $-460(%rip) +LBB0_813: + WORD $0x92800031 // mov x17, #-2 + WORD $0xaa0e03fa // mov x26, x14 + WORD $0x17fffffb // b LBB0_812 $-20(%rip) +LBB0_814: + WORD $0x92800071 // mov x17, #-4 + WORD $0xaa1603fa // mov x26, x22 + WORD $0x17fffff8 // b LBB0_812 $-32(%rip) +LBB0_815: + WORD $0xaa1603fa // mov x26, x22 + WORD $0x17fffff6 // b LBB0_812 $-40(%rip) +LBB0_816: + WORD $0x92800071 // mov x17, #-4 + WORD $0xaa0e03fa // mov x26, x14 + WORD $0x17fffff3 // b LBB0_812 $-52(%rip) + // .p2align 1, 0x00 +LJTI0_0: + WORD $0x0024002b + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240070 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00000024 + WORD $0x00240024 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x01ac0024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x002400b0 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x0024006b + WORD $0x00240024 + WORD $0x00240024 + WORD $0x0024006b + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00b70024 + // // .word (LBB0_393-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_418-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_379-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_452-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_425-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_417-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_417-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_390-LBB0_379)>>2 +// .word (LBB0_427-LBB0_379)>>2 + +LJTI0_1: + WORD $0x0024002b + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240082 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00000024 + WORD $0x00240024 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00cb0024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x002400c4 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240072 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x00240072 + WORD $0x00240024 + WORD $0x00240024 + WORD $0x01c00024 + // // .word (LBB0_150-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_180-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_136-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_192-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_190-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_176-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_176-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_147-LBB0_136)>>2 +// .word (LBB0_217-LBB0_136)>>2 + +LJTI0_2: + WORD $0x00ff0000 + WORD $0x01080005 + WORD $0x010c0069 + // // .word (LBB0_524-LBB0_524)>>2 +// .word (LBB0_575-LBB0_524)>>2 +// .word (LBB0_526-LBB0_524)>>2 +// .word (LBB0_578-LBB0_524)>>2 +// .word (LBB0_539-LBB0_524)>>2 +// .word (LBB0_580-LBB0_524)>>2 + +LJTI0_3: + WORD $0x03f103f8 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f1012b + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x018703f1 + WORD $0x03f103f1 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x019203f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f1019a + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f101a5 + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x03f101af + WORD $0x03f103f1 + WORD $0x03f103f1 + WORD $0x01ba03f1 + // // .word (LBB0_778-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_615-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_625-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_544-LBB0_544)>>2 +// .word (LBB0_544-LBB0_544)>>2 +// .word (LBB0_544-LBB0_544)>>2 +// .word (LBB0_544-LBB0_544)>>2 +// .word (LBB0_544-LBB0_544)>>2 +// .word (LBB0_544-LBB0_544)>>2 +// .word (LBB0_544-LBB0_544)>>2 +// .word (LBB0_544-LBB0_544)>>2 +// .word (LBB0_544-LBB0_544)>>2 +// .word (LBB0_544-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_629-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_631-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_634-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_636-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_774-LBB0_544)>>2 +// .word (LBB0_639-LBB0_544)>>2 + +LJTI0_4: + WORD $0x12001e00 + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x00181e1e + // // .byte (LBB0_663-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_663-LBB0_663)>>2 +// .byte (LBB0_669-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_675-LBB0_663)>>2 +// .byte (LBB0_672-LBB0_663)>>2 + +LJTI0_5: + WORD $0x17139f13 + WORD $0x9f9f9f9f + WORD $0x9f9f9f9f + WORD $0x9f9f9f9f + WORD $0x9f9f9f9f + WORD $0x9f9f9f9f + WORD $0x00009f9f + // // .byte (LBB0_573-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_573-LBB0_568)>>2 +// .byte (LBB0_574-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_599-LBB0_568)>>2 +// .byte (LBB0_568-LBB0_568)>>2 + +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 +__UnquoteTab: + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00220000 // .ascii 4, '\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00/\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x2f000000 // .ascii 4, '\x00\x00\x00/\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00\x00\x00\x08\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\\\x00\x00\x00\x00\x00\x08\x00\x00\x00\x0c\x00' + WORD $0x0000005c // .ascii 4, '\\\x00\x00\x00\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00' + WORD $0x00080000 // .ascii 4, '\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00' + WORD $0x000c0000 // .ascii 4, '\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\r\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\r\x00\t\xff\x00\x00' + WORD $0x000a0000 // .ascii 4, '\x00\x00\n\x00\x00\x00\r\x00\t\xff\x00\x00' + WORD $0x000d0000 // .ascii 4, '\x00\x00\r\x00\t\xff\x00\x00' + WORD $0x0000ff09 // .ascii 4, '\t\xff\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + +TEXT ·__get_by_path(SB), $0-40 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $256, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_get_by_path: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + MOVD path+16(FP), R2 + MOVD m+24(FP), R3 + CALL ·__get_by_path_arm64_entry__+76(SB) // _get_by_path + MOVD R0, ret+32(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/get_by_path_subr_arm64.go b/internal/native/neon/get_by_path_subr_arm64.go new file mode 100644 index 000000000..f910a2c55 --- /dev/null +++ b/internal/native/neon/get_by_path_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __get_by_path_arm64_entry__() uintptr + +var ( + _subr__get_by_path uintptr = __get_by_path_arm64_entry__() + 64 +) + +const ( + _stack__get_by_path = 224 +) + +var ( + _ = _subr__get_by_path +) + +const ( + _ = _stack__get_by_path +) diff --git a/internal/native/neon/html_escape_arm64.go b/internal/native/neon/html_escape_arm64.go new file mode 100644 index 000000000..579af585b --- /dev/null +++ b/internal/native/neon/html_escape_arm64.go @@ -0,0 +1,37 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + `unsafe` + + // `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) { + return __html_escape(sp, nb, dp, dn) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) diff --git a/internal/native/neon/html_escape_arm64.s b/internal/native/neon/html_escape_arm64.s new file mode 100644 index 000000000..2fdc3c0aa --- /dev/null +++ b/internal/native/neon/html_escape_arm64.s @@ -0,0 +1,1415 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__html_escape_arm64_entry__(SB), NOSPLIT, $32 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_1: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_html_escape: + MOVD.W R30, -48(RSP) // WORD $0xf81d0ffe // str x30, [sp, #-48]! + WORD $0xa9024ff4 // stp x20, x19, [sp, #32] + WORD $0xaa0203e8 // mov x8, x2 + WORD $0xaa0003ef // mov x15, x0 + WORD $0xf100043f // cmp x1, #1 + WORD $0x54001eab // b.lt LBB0_57 $980(%rip) + WORD $0xf940006e // ldr x14, [x3] + WORD $0x4f01e4c0 // movi.16b v0, #38 + WORD $0x4f07e441 // movi.16b v1, #226 + WORD $0x4f07e7a2 // movi.16b v2, #253 +Lloh0: + WORD $0x10fffdc8 // adr x8, lCPI0_0 $-72(%rip) +Lloh1: + WORD $0x3dc00103 // ldr q3, [x8, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x4f01e784 // movi.16b v4, #60 +Lloh2: + WORD $0x10fffde8 // adr x8, lCPI0_1 $-68(%rip) +Lloh3: + WORD $0x3dc00105 // ldr q5, [x8, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x52800029 // mov w9, #1 + WORD $0xd2c0080a // mov x10, #274877906944 + WORD $0xf2ea000a // movk x10, #20480, lsl #48 + WORD $0x52801c4b // mov w11, #226 +Lloh4: + WORD $0x10001fac // adr x12, __HtmlQuoteTab $1012(%rip) +Lloh5: + WORD $0x9100018c // add x12, x12, __HtmlQuoteTab@PAGEOFF $0(%rip) + WORD $0xd280002d // mov x13, #1 + WORD $0xf2c0006d // movk x13, #3, lsl #32 + WORD $0xaa0003ef // mov x15, x0 + WORD $0xaa0203e8 // mov x8, x2 + WORD $0x14000005 // b LBB0_3 $20(%rip) +LBB0_2: + WORD $0x8b010108 // add x8, x8, x1 + WORD $0x9100062f // add x15, x17, #1 + WORD $0xf1000601 // subs x1, x16, #1 + WORD $0x54001ba9 // b.ls LBB0_57 $884(%rip) +LBB0_3: + WORD $0xf10001df // cmp x14, #0 + WORD $0x54001d8d // b.le LBB0_60 $944(%rip) + WORD $0xf1003c3f // cmp x1, #15 + WORD $0x1a9f97e6 // cset w6, hi + WORD $0xaa0e03e4 // mov x4, x14 + WORD $0xaa0803f1 // mov x17, x8 + WORD $0xaa0103e5 // mov x5, x1 + WORD $0xaa0f03f0 // mov x16, x15 + WORD $0xf10041df // cmp x14, #16 + WORD $0x54000403 // b.lo LBB0_11 $128(%rip) + WORD $0xf100403f // cmp x1, #16 + WORD $0x540003c3 // b.lo LBB0_11 $120(%rip) + WORD $0xd2800011 // mov x17, #0 + WORD $0xaa0103e7 // mov x7, x1 + WORD $0xaa0e03f0 // mov x16, x14 +LBB0_7: + WORD $0x3cf169e6 // ldr q6, [x15, x17] + WORD $0x6e208cc7 // cmeq.16b v7, v6, v0 + WORD $0x6e218cd0 // cmeq.16b v16, v6, v1 + WORD $0x4e221cd1 // and.16b v17, v6, v2 + WORD $0x6e248e31 // cmeq.16b v17, v17, v4 + WORD $0x4ea71e07 // orr.16b v7, v16, v7 + WORD $0x4eb11ce7 // orr.16b v7, v7, v17 + WORD $0x3cb16906 // str q6, [x8, x17] + WORD $0x4e231ce6 // and.16b v6, v7, v3 + WORD $0x4e0500c6 // tbl.16b v6, { v6 }, v5 + WORD $0x4e71b8c6 // addv.8h h6, v6 + WORD $0x1e2600c4 // fmov w4, s6 + WORD $0x35000824 // cbnz w4, LBB0_22 $260(%rip) + WORD $0xd10040e5 // sub x5, x7, #16 + WORD $0xd1004204 // sub x4, x16, #16 + WORD $0xf1007cff // cmp x7, #31 + WORD $0x1a9fd7e6 // cset w6, gt + WORD $0x91004231 // add x17, x17, #16 + WORD $0xf10080ff // cmp x7, #32 + WORD $0x540000ab // b.lt LBB0_10 $20(%rip) + WORD $0xaa0503e7 // mov x7, x5 + WORD $0xf1007e1f // cmp x16, #31 + WORD $0xaa0403f0 // mov x16, x4 + WORD $0x54fffd2c // b.gt LBB0_7 $-92(%rip) +LBB0_10: + WORD $0x8b1101f0 // add x16, x15, x17 + WORD $0x8b110111 // add x17, x8, x17 +LBB0_11: + WORD $0x36000346 // tbz w6, #0, LBB0_15 $104(%rip) + WORD $0x3dc00206 // ldr q6, [x16] + WORD $0x6e208cc7 // cmeq.16b v7, v6, v0 + WORD $0x6e218cd0 // cmeq.16b v16, v6, v1 + WORD $0x4e221cd1 // and.16b v17, v6, v2 + WORD $0x6e248e31 // cmeq.16b v17, v17, v4 + WORD $0x4ea71e07 // orr.16b v7, v16, v7 + WORD $0x4eb11ce7 // orr.16b v7, v7, v17 + WORD $0x4e231ce7 // and.16b v7, v7, v3 + WORD $0x4e0500e7 // tbl.16b v7, { v7 }, v5 + WORD $0x4e71b8e7 // addv.8h h7, v7 + WORD $0x1e2600e5 // fmov w5, s7 + WORD $0x52a00026 // mov w6, #65536 + WORD $0x33003ca6 // bfxil w6, w5, #0, #16 + WORD $0x5ac000c5 // rbit w5, w6 + WORD $0x5ac010a5 // clz w5, w5 + WORD $0x9e6600c7 // fmov x7, d6 + WORD $0xeb05009f // cmp x4, x5 + WORD $0x540004ca // b.ge LBB0_23 $152(%rip) + WORD $0xf1002086 // subs x6, x4, #8 + WORD $0x54000b63 // b.lo LBB0_37 $364(%rip) + WORD $0xf8008627 // str x7, [x17], #8 + WORD $0x91002205 // add x5, x16, #8 + WORD $0xf10010c7 // subs x7, x6, #4 + WORD $0x54000b6a // b.ge LBB0_38 $364(%rip) + WORD $0x1400005d // b LBB0_39 $372(%rip) +LBB0_15: + WORD $0xf10004bf // cmp x5, #1 + WORD $0x540004ab // b.lt LBB0_25 $148(%rip) + WORD $0xf100049f // cmp x4, #1 + WORD $0x5400046b // b.lt LBB0_25 $140(%rip) + WORD $0xcb0f0206 // sub x6, x16, x15 +LBB0_18: + WORD $0x39400213 // ldrb w19, [x16] + WORD $0x7100fa7f // cmp w19, #62 + WORD $0x9ad32127 // lsl x7, x9, x19 + WORD $0x8a0a00e7 // and x7, x7, x10 + WORD $0xfa4098e4 // ccmp x7, #0, #4, ls + WORD $0x54000441 // b.ne LBB0_27 $136(%rip) + WORD $0x71038a7f // cmp w19, #226 + WORD $0x54000400 // b.eq LBB0_27 $128(%rip) + WORD $0xd10004a7 // sub x7, x5, #1 + WORD $0x91000610 // add x16, x16, #1 + WORD $0x38001633 // strb w19, [x17], #1 + WORD $0xf10008bf // cmp x5, #2 + WORD $0x540002cb // b.lt LBB0_26 $88(%rip) + WORD $0xd1000493 // sub x19, x4, #1 + WORD $0x910004c6 // add x6, x6, #1 + WORD $0xaa0703e5 // mov x5, x7 + WORD $0xf100049f // cmp x4, #1 + WORD $0xaa1303e4 // mov x4, x19 + WORD $0x54fffdcc // b.gt LBB0_18 $-72(%rip) + WORD $0x1400000f // b LBB0_26 $60(%rip) +LBB0_22: + WORD $0x5ac00090 // rbit w16, w4 + WORD $0x5ac01210 // clz w16, w16 + WORD $0x8b110206 // add x6, x16, x17 + WORD $0xb6f80226 // tbz x6, #63, LBB0_28 $68(%rip) + WORD $0x14000082 // b LBB0_58 $520(%rip) +LBB0_23: + WORD $0x710020bf // cmp w5, #8 + WORD $0x54000983 // b.lo LBB0_44 $304(%rip) + WORD $0xf8008627 // str x7, [x17], #8 + WORD $0x91002204 // add x4, x16, #8 + WORD $0xd10020a6 // sub x6, x5, #8 + WORD $0xf10010c7 // subs x7, x6, #4 + WORD $0x54000962 // b.hs LBB0_45 $300(%rip) + WORD $0x1400004d // b LBB0_46 $308(%rip) +LBB0_25: + WORD $0xaa0503e7 // mov x7, x5 +LBB0_26: + WORD $0xaa3003f1 // mvn x17, x16 + WORD $0x8b0f0231 // add x17, x17, x15 + WORD $0xcb0f0210 // sub x16, x16, x15 + WORD $0xf10000ff // cmp x7, #0 + WORD $0x9a901226 // csel x6, x17, x16, ne +LBB0_27: + WORD $0xb7f80e66 // tbnz x6, #63, LBB0_58 $460(%rip) +LBB0_28: + WORD $0x8b0601ef // add x15, x15, x6 + WORD $0x8b060108 // add x8, x8, x6 + WORD $0xcb060030 // sub x16, x1, x6 + WORD $0xf100061f // cmp x16, #1 + WORD $0x54000d0b // b.lt LBB0_57 $416(%rip) + WORD $0xcb0601ce // sub x14, x14, x6 + WORD $0x394001e1 // ldrb w1, [x15] + WORD $0x7103883f // cmp w1, #226 + WORD $0x54000960 // b.eq LBB0_51 $300(%rip) + WORD $0xaa0f03f1 // mov x17, x15 + WORD $0x2a0103e4 // mov w4, w1 + WORD $0xd37cec81 // lsl x1, x4, #4 + WORD $0xf8616985 // ldr x5, [x12, x1] + WORD $0x93407ca1 // sxtw x1, w5 + WORD $0xeb0101ce // subs x14, x14, x1 + WORD $0x54000d8b // b.lt LBB0_59 $432(%rip) +LBB0_31: + WORD $0xd3607ca6 // lsl x6, x5, #32 + WORD $0x8b041185 // add x5, x12, x4, lsl #4 + WORD $0x910020af // add x15, x5, #8 + WORD $0xeb0d00df // cmp x6, x13 + WORD $0x5400012b // b.lt LBB0_33 $36(%rip) + WORD $0xb94001ef // ldr w15, [x15] + WORD $0xaa0803e4 // mov x4, x8 + WORD $0xb800448f // str w15, [x4], #4 + WORD $0x910030af // add x15, x5, #12 + WORD $0xd1001025 // sub x5, x1, #4 + WORD $0xf10008a6 // subs x6, x5, #2 + WORD $0x540000c2 // b.hs LBB0_34 $24(%rip) + WORD $0x14000008 // b LBB0_35 $32(%rip) +LBB0_33: + WORD $0xaa0803e4 // mov x4, x8 + WORD $0xaa0103e5 // mov x5, x1 + WORD $0xf10008a6 // subs x6, x5, #2 + WORD $0x54000083 // b.lo LBB0_35 $16(%rip) +LBB0_34: + WORD $0x784025e5 // ldrh w5, [x15], #2 + WORD $0x78002485 // strh w5, [x4], #2 + WORD $0xaa0603e5 // mov x5, x6 +LBB0_35: + WORD $0xb4ffed05 // cbz x5, LBB0_2 $-608(%rip) + WORD $0x394001ef // ldrb w15, [x15] + WORD $0x3900008f // strb w15, [x4] + WORD $0x17ffff65 // b LBB0_2 $-620(%rip) +LBB0_37: + WORD $0xaa1003e5 // mov x5, x16 + WORD $0xaa0403e6 // mov x6, x4 + WORD $0xf10010c7 // subs x7, x6, #4 + WORD $0x5400008b // b.lt LBB0_39 $16(%rip) +LBB0_38: + WORD $0xb84044a6 // ldr w6, [x5], #4 + WORD $0xb8004626 // str w6, [x17], #4 + WORD $0xaa0703e6 // mov x6, x7 +LBB0_39: + WORD $0xf10008c7 // subs x7, x6, #2 + WORD $0x540000c3 // b.lo LBB0_41 $24(%rip) + WORD $0x784024a6 // ldrh w6, [x5], #2 + WORD $0x78002626 // strh w6, [x17], #2 + WORD $0xaa0703e6 // mov x6, x7 + WORD $0xb5000066 // cbnz x6, LBB0_42 $12(%rip) + WORD $0x14000004 // b LBB0_43 $16(%rip) +LBB0_41: + WORD $0xb4000066 // cbz x6, LBB0_43 $12(%rip) +LBB0_42: + WORD $0x394000a5 // ldrb w5, [x5] + WORD $0x39000225 // strb w5, [x17] +LBB0_43: + WORD $0x8b100090 // add x16, x4, x16 + WORD $0xaa3003f0 // mvn x16, x16 + WORD $0x8b0f0206 // add x6, x16, x15 + WORD $0xb6fff886 // tbz x6, #63, LBB0_28 $-240(%rip) + WORD $0x14000035 // b LBB0_58 $212(%rip) +LBB0_44: + WORD $0xaa1003e4 // mov x4, x16 + WORD $0xaa0503e6 // mov x6, x5 + WORD $0xf10010c7 // subs x7, x6, #4 + WORD $0x54000083 // b.lo LBB0_46 $16(%rip) +LBB0_45: + WORD $0xb8404486 // ldr w6, [x4], #4 + WORD $0xb8004626 // str w6, [x17], #4 + WORD $0xaa0703e6 // mov x6, x7 +LBB0_46: + WORD $0xf10008c7 // subs x7, x6, #2 + WORD $0x540000c3 // b.lo LBB0_48 $24(%rip) + WORD $0x78402486 // ldrh w6, [x4], #2 + WORD $0x78002626 // strh w6, [x17], #2 + WORD $0xaa0703e6 // mov x6, x7 + WORD $0xb5000066 // cbnz x6, LBB0_49 $12(%rip) + WORD $0x14000004 // b LBB0_50 $16(%rip) +LBB0_48: + WORD $0xb4000066 // cbz x6, LBB0_50 $12(%rip) +LBB0_49: + WORD $0x39400084 // ldrb w4, [x4] + WORD $0x39000224 // strb w4, [x17] +LBB0_50: + WORD $0xcb0f0210 // sub x16, x16, x15 + WORD $0x8b050206 // add x6, x16, x5 + WORD $0xb6fff5e6 // tbz x6, #63, LBB0_28 $-324(%rip) + WORD $0x14000020 // b LBB0_58 $128(%rip) +LBB0_51: + WORD $0xf1000e1f // cmp x16, #3 + WORD $0x54000223 // b.lo LBB0_55 $68(%rip) + WORD $0x394005f1 // ldrb w17, [x15, #1] + WORD $0x7102023f // cmp w17, #128 + WORD $0x540001c1 // b.ne LBB0_55 $56(%rip) + WORD $0xaa0f03f1 // mov x17, x15 + WORD $0x38402e21 // ldrb w1, [x17, #2]! + WORD $0x121f1824 // and w4, w1, #0xfe + WORD $0x7102a09f // cmp w4, #168 + WORD $0x54000121 // b.ne LBB0_55 $36(%rip) + WORD $0xd1000a10 // sub x16, x16, #2 + WORD $0x2a0103e4 // mov w4, w1 + WORD $0xd37cec81 // lsl x1, x4, #4 + WORD $0xf8616985 // ldr x5, [x12, x1] + WORD $0x93407ca1 // sxtw x1, w5 + WORD $0xeb0101ce // subs x14, x14, x1 + WORD $0x54fff5aa // b.ge LBB0_31 $-332(%rip) + WORD $0x14000017 // b LBB0_59 $92(%rip) +LBB0_55: + WORD $0xf10005ce // subs x14, x14, #1 + WORD $0x540002eb // b.lt LBB0_60 $92(%rip) + WORD $0x3800150b // strb w11, [x8], #1 + WORD $0xaa0f03f1 // mov x17, x15 + WORD $0x9100062f // add x15, x17, #1 + WORD $0xf1000601 // subs x1, x16, #1 + WORD $0x54ffe4a8 // b.hi LBB0_3 $-876(%rip) +LBB0_57: + WORD $0xcb020108 // sub x8, x8, x2 + WORD $0xf9000068 // str x8, [x3] + WORD $0xcb0001e0 // sub x0, x15, x0 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_58: + WORD $0x8b0200c9 // add x9, x6, x2 + WORD $0xaa2903e9 // mvn x9, x9 + WORD $0x8b080128 // add x8, x9, x8 + WORD $0xf9000068 // str x8, [x3] + WORD $0xcb0f0008 // sub x8, x0, x15 + WORD $0x8b060100 // add x0, x8, x6 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_59: + WORD $0xcb020108 // sub x8, x8, x2 + WORD $0xf9000068 // str x8, [x3] +LBB0_60: + WORD $0xaa2f03e8 // mvn x8, x15 + WORD $0x8b000100 // add x0, x8, x0 + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret + // .p2align 3, 0x00 +__HtmlQuoteTab: + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000006; WORD $0x00000000 // .quad 6 + WORD $0x3030755c // .asciz 4, '\\u0026\x00\x00' + WORD $0x00003632 // .asciz 4, '26\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000006; WORD $0x00000000 // .quad 6 + WORD $0x3030755c // .asciz 4, '\\u003c\x00\x00' + WORD $0x00006333 // .asciz 4, '3c\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000006; WORD $0x00000000 // .quad 6 + WORD $0x3030755c // .asciz 4, '\\u003e\x00\x00' + WORD $0x00006533 // .asciz 4, '3e\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000006; WORD $0x00000000 // .quad 6 + WORD $0x3032755c // .asciz 4, '\\u2028\x00\x00' + WORD $0x00003832 // .asciz 4, '28\x00\x00' + WORD $0x00000006; WORD $0x00000000 // .quad 6 + WORD $0x3032755c // .asciz 4, '\\u2029\x00\x00' + WORD $0x00003932 // .asciz 4, '29\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + +TEXT ·__html_escape(SB), $0-40 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $80, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_html_escape: + MOVD sp+0(FP), R0 + MOVD nb+8(FP), R1 + MOVD dp+16(FP), R2 + MOVD dn+24(FP), R3 + CALL ·__html_escape_arm64_entry__+60(SB) // _html_escape + MOVD R0, ret+32(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/html_escape_subr_arm64.go b/internal/native/neon/html_escape_subr_arm64.go new file mode 100644 index 000000000..0e6ce37e4 --- /dev/null +++ b/internal/native/neon/html_escape_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __html_escape_arm64_entry__() uintptr + +var ( + _subr__html_escape uintptr = __html_escape_arm64_entry__() + 48 +) + +const ( + _stack__html_escape = 48 +) + +var ( + _ = _subr__html_escape +) + +const ( + _ = _stack__html_escape +) diff --git a/internal/native/neon/i64toa_arm64.go b/internal/native/neon/i64toa_arm64.go new file mode 100644 index 000000000..d383b3843 --- /dev/null +++ b/internal/native/neon/i64toa_arm64.go @@ -0,0 +1,31 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +//go:nosplit +func i64toa(out *byte, val int64) (ret int) { + return __i64toa(out, val) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __i64toa(out *byte, val int64) (ret int) diff --git a/internal/native/neon/i64toa_arm64.s b/internal/native/neon/i64toa_arm64.s new file mode 100644 index 000000000..b45b5e420 --- /dev/null +++ b/internal/native/neon/i64toa_arm64.s @@ -0,0 +1,964 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__i64toa_arm64_entry__(SB), NOSPLIT, $16 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 3, 0x00 +lCPI0_0: + WORD $0x147b20c5 + WORD $0x80003334 + // // .word 8389 +// .word 5243 +// .word 13108 +// .word 32768 + +lCPI0_1: + WORD $0x08000080 + WORD $0x80002000 + // // .word 128 +// .word 2048 +// .word 8192 +// .word 32768 + +lCPI0_2: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_3: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_i64toa: + MOVD.W R30, -32(RSP) // WORD $0xf81e0ffe // str x30, [sp, #-32]! + WORD $0xb7f80661 // tbnz x1, #63, LBB0_10 $204(%rip) + WORD $0xd344fc28 // lsr x8, x1, #4 + WORD $0xf109c11f // cmp x8, #624 + WORD $0x54000908 // b.hi LBB0_13 $288(%rip) + WORD $0x53023c28 // ubfx w8, w1, #2, #14 + WORD $0x52828f69 // mov w9, #5243 + WORD $0x1b097d08 // mul w8, w8, w9 + WORD $0x53117d08 // lsr w8, w8, #17 + WORD $0xd37ff909 // lsl x9, x8, #1 + WORD $0x52800c8a // mov w10, #100 + WORD $0x1b0a8508 // msub w8, w8, w10, w1 + WORD $0x92403d08 // and x8, x8, #0xffff + WORD $0xd37ff908 // lsl x8, x8, #1 + WORD $0x710fa03f // cmp w1, #1000 + WORD $0x540000e3 // b.lo LBB0_4 $28(%rip) +Lloh0: + WORD $0x100052ea // adr x10, _Digits $2652(%rip) +Lloh1: + WORD $0x9100014a // add x10, x10, _Digits@PAGEOFF $0(%rip) + WORD $0x3869694a // ldrb w10, [x10, x9] + WORD $0x3900000a // strb w10, [x0] + WORD $0x5280002a // mov w10, #1 + WORD $0x14000004 // b LBB0_6 $16(%rip) +LBB0_4: + WORD $0x7101903f // cmp w1, #100 + WORD $0x54000303 // b.lo LBB0_9 $96(%rip) + WORD $0x5280000a // mov w10, #0 +LBB0_6: + WORD $0x2a0903e9 // mov w9, w9 +Lloh2: + WORD $0x100051ab // adr x11, _Digits $2612(%rip) +Lloh3: + WORD $0x9100016b // add x11, x11, _Digits@PAGEOFF $0(%rip) + WORD $0xb2400129 // orr x9, x9, #0x1 + WORD $0x38696969 // ldrb w9, [x11, x9] + WORD $0x1100054b // add w11, w10, #1 + WORD $0x382a4809 // strb w9, [x0, w10, uxtw] +LBB0_7: +Lloh4: + WORD $0x100050e9 // adr x9, _Digits $2588(%rip) +Lloh5: + WORD $0x91000129 // add x9, x9, _Digits@PAGEOFF $0(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x11000569 // add w9, w11, #1 + WORD $0x382b480a // strb w10, [x0, w11, uxtw] +LBB0_8: + WORD $0x32000108 // orr w8, w8, #0x1 +Lloh6: + WORD $0x1000502a // adr x10, _Digits $2564(%rip) +Lloh7: + WORD $0x9100014a // add x10, x10, _Digits@PAGEOFF $0(%rip) + WORD $0x92403d08 // and x8, x8, #0xffff + WORD $0x3868694a // ldrb w10, [x10, x8] + WORD $0x11000528 // add w8, w9, #1 + WORD $0x3829480a // strb w10, [x0, w9, uxtw] + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_9: + WORD $0x5280000b // mov w11, #0 + WORD $0x52800009 // mov w9, #0 + WORD $0x7100283f // cmp w1, #10 + WORD $0x54fffdc2 // b.hs LBB0_7 $-72(%rip) + WORD $0x17fffff2 // b LBB0_8 $-56(%rip) +LBB0_10: + WORD $0x528005a9 // mov w9, #45 + WORD $0xaa0003e8 // mov x8, x0 + WORD $0x38001509 // strb w9, [x8], #1 + WORD $0xcb0103ea // neg x10, x1 + WORD $0xd344fd49 // lsr x9, x10, #4 + WORD $0xf109c13f // cmp x9, #624 + WORD $0x540010c8 // b.hi LBB0_28 $536(%rip) + WORD $0x53023d49 // ubfx w9, w10, #2, #14 + WORD $0x52828f6b // mov w11, #5243 + WORD $0x1b0b7d29 // mul w9, w9, w11 + WORD $0x53117d29 // lsr w9, w9, #17 + WORD $0xd37ff92b // lsl x11, x9, #1 + WORD $0x52800c8c // mov w12, #100 + WORD $0x1b0ca929 // msub w9, w9, w12, w10 + WORD $0x92403d29 // and x9, x9, #0xffff + WORD $0xd37ff929 // lsl x9, x9, #1 + WORD $0x710fa15f // cmp w10, #1000 + WORD $0x54000603 // b.lo LBB0_16 $192(%rip) +Lloh8: + WORD $0x10004c2a // adr x10, _Digits $2436(%rip) +Lloh9: + WORD $0x9100014a // add x10, x10, _Digits@PAGEOFF $0(%rip) + WORD $0x386b694a // ldrb w10, [x10, x11] + WORD $0x3900010a // strb w10, [x8] + WORD $0x5280002a // mov w10, #1 + WORD $0x1400002d // b LBB0_18 $180(%rip) +LBB0_13: + WORD $0x529c2008 // mov w8, #57600 + WORD $0x72a0bea8 // movk w8, #1525, lsl #16 + WORD $0xeb08003f // cmp x1, x8 + WORD $0x54001322 // b.hs LBB0_31 $612(%rip) + WORD $0x528847ec // mov w12, #16959 + WORD $0x72a001ec // movk w12, #15, lsl #16 + WORD $0x92407c28 // and x8, x1, #0xffffffff + WORD $0x5282eb29 // mov w9, #5977 + WORD $0x72ba36e9 // movk w9, #53687, lsl #16 + WORD $0x9b097d08 // mul x8, x8, x9 + WORD $0xd36dfd08 // lsr x8, x8, #45 + WORD $0x5284e209 // mov w9, #10000 + WORD $0x1b09850d // msub w13, w8, w9, w1 + WORD $0x11000589 // add w9, w12, #1 + WORD $0x1ac90829 // udiv w9, w1, w9 + WORD $0xd37ff92b // lsl x11, x9, #1 + WORD $0x53023d09 // ubfx w9, w8, #2, #14 + WORD $0x52828f6e // mov w14, #5243 + WORD $0x1b0e7d29 // mul w9, w9, w14 + WORD $0x53117d29 // lsr w9, w9, #17 + WORD $0x52800c8f // mov w15, #100 + WORD $0x1b0fa128 // msub w8, w9, w15, w8 + WORD $0x92403d08 // and x8, x8, #0xffff + WORD $0xd37ff90a // lsl x10, x8, #1 + WORD $0x53023da8 // ubfx w8, w13, #2, #14 + WORD $0x1b0e7d08 // mul w8, w8, w14 + WORD $0x53117d08 // lsr w8, w8, #17 + WORD $0xd37ff909 // lsl x9, x8, #1 + WORD $0x1b0fb508 // msub w8, w8, w15, w13 + WORD $0x92403d08 // and x8, x8, #0xffff + WORD $0xd37ff908 // lsl x8, x8, #1 + WORD $0x5292cfed // mov w13, #38527 + WORD $0x72a0130d // movk w13, #152, lsl #16 + WORD $0x6b0d003f // cmp w1, w13 + WORD $0x54000429 // b.ls LBB0_21 $132(%rip) +Lloh10: + WORD $0x1000470c // adr x12, _Digits $2272(%rip) +Lloh11: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0x386b698c // ldrb w12, [x12, x11] + WORD $0x3900000c // strb w12, [x0] + WORD $0x5280002d // mov w13, #1 + WORD $0x1400001e // b LBB0_23 $120(%rip) +LBB0_16: + WORD $0x7101915f // cmp w10, #100 + WORD $0x540007e3 // b.lo LBB0_26 $252(%rip) + WORD $0x5280000a // mov w10, #0 +LBB0_18: + WORD $0x2a0b03eb // mov w11, w11 +Lloh12: + WORD $0x100045cc // adr x12, _Digits $2232(%rip) +Lloh13: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0xb240016b // orr x11, x11, #0x1 + WORD $0x386b698b // ldrb w11, [x12, x11] + WORD $0x1100054c // add w12, w10, #1 + WORD $0x382a490b // strb w11, [x8, w10, uxtw] +LBB0_19: +Lloh14: + WORD $0x1000450a // adr x10, _Digits $2208(%rip) +Lloh15: + WORD $0x9100014a // add x10, x10, _Digits@PAGEOFF $0(%rip) + WORD $0x3869694a // ldrb w10, [x10, x9] + WORD $0x1100058b // add w11, w12, #1 + WORD $0x382c490a // strb w10, [x8, w12, uxtw] +LBB0_20: + WORD $0x32000129 // orr w9, w9, #0x1 +Lloh16: + WORD $0x1000444a // adr x10, _Digits $2184(%rip) +Lloh17: + WORD $0x9100014a // add x10, x10, _Digits@PAGEOFF $0(%rip) + WORD $0x92403d29 // and x9, x9, #0xffff + WORD $0x3869694a // ldrb w10, [x10, x9] + WORD $0x11000569 // add w9, w11, #1 + WORD $0x382b490a // strb w10, [x8, w11, uxtw] + WORD $0x11000528 // add w8, w9, #1 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_21: + WORD $0x6b0c003f // cmp w1, w12 + WORD $0x54000549 // b.ls LBB0_27 $168(%rip) + WORD $0x5280000d // mov w13, #0 +LBB0_23: + WORD $0x2a0b03eb // mov w11, w11 +Lloh18: + WORD $0x1000428c // adr x12, _Digits $2128(%rip) +Lloh19: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0xb240016b // orr x11, x11, #0x1 + WORD $0x386b698b // ldrb w11, [x12, x11] + WORD $0x110005ac // add w12, w13, #1 + WORD $0x382d480b // strb w11, [x0, w13, uxtw] +LBB0_24: +Lloh20: + WORD $0x100041cb // adr x11, _Digits $2104(%rip) +Lloh21: + WORD $0x9100016b // add x11, x11, _Digits@PAGEOFF $0(%rip) + WORD $0x386a696d // ldrb w13, [x11, x10] + WORD $0x1100058b // add w11, w12, #1 + WORD $0x382c480d // strb w13, [x0, w12, uxtw] +LBB0_25: + WORD $0x3200014a // orr w10, w10, #0x1 + WORD $0x92403d4a // and x10, x10, #0xffff +Lloh22: + WORD $0x100040ec // adr x12, _Digits $2076(%rip) +Lloh23: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0x386a698a // ldrb w10, [x12, x10] + WORD $0x8b2b400d // add x13, x0, w11, uxtw + WORD $0x390001aa // strb w10, [x13] + WORD $0x3869698a // ldrb w10, [x12, x9] + WORD $0x390005aa // strb w10, [x13, #1] + WORD $0x2a0903e9 // mov w9, w9 + WORD $0xb2400129 // orr x9, x9, #0x1 + WORD $0x38696989 // ldrb w9, [x12, x9] + WORD $0x390009a9 // strb w9, [x13, #2] + WORD $0x38686989 // ldrb w9, [x12, x8] + WORD $0x39000da9 // strb w9, [x13, #3] + WORD $0x32000108 // orr w8, w8, #0x1 + WORD $0x92403d08 // and x8, x8, #0xffff + WORD $0x38686989 // ldrb w9, [x12, x8] + WORD $0x11001568 // add w8, w11, #5 + WORD $0x390011a9 // strb w9, [x13, #4] + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_26: + WORD $0x5280000c // mov w12, #0 + WORD $0x5280000b // mov w11, #0 + WORD $0x7100295f // cmp w10, #10 + WORD $0x54fff8e2 // b.hs LBB0_19 $-228(%rip) + WORD $0x17ffffcb // b LBB0_20 $-212(%rip) +LBB0_27: + WORD $0x5280000c // mov w12, #0 + WORD $0x5280000b // mov w11, #0 + WORD $0x53057c2d // lsr w13, w1, #5 + WORD $0x7130d5bf // cmp w13, #3125 + WORD $0x54fffb62 // b.hs LBB0_24 $-148(%rip) + WORD $0x17ffffdf // b LBB0_25 $-132(%rip) +LBB0_28: + WORD $0x529c2009 // mov w9, #57600 + WORD $0x72a0bea9 // movk w9, #1525, lsl #16 + WORD $0xeb09015f // cmp x10, x9 + WORD $0x540015c2 // b.hs LBB0_39 $696(%rip) + WORD $0x528847ee // mov w14, #16959 + WORD $0x72a001ee // movk w14, #15, lsl #16 + WORD $0x5282eb29 // mov w9, #5977 + WORD $0x72ba36e9 // movk w9, #53687, lsl #16 + WORD $0x9ba97d49 // umull x9, w10, w9 + WORD $0xd36dfd29 // lsr x9, x9, #45 + WORD $0x5284e20b // mov w11, #10000 + WORD $0x1b0ba92f // msub w15, w9, w11, w10 + WORD $0x110005cb // add w11, w14, #1 + WORD $0x1acb094b // udiv w11, w10, w11 + WORD $0xd37ff96d // lsl x13, x11, #1 + WORD $0x53023d2b // ubfx w11, w9, #2, #14 + WORD $0x52828f70 // mov w16, #5243 + WORD $0x1b107d6b // mul w11, w11, w16 + WORD $0x53117d6b // lsr w11, w11, #17 + WORD $0x52800c91 // mov w17, #100 + WORD $0x1b11a569 // msub w9, w11, w17, w9 + WORD $0x92403d29 // and x9, x9, #0xffff + WORD $0xd37ff92c // lsl x12, x9, #1 + WORD $0x53023de9 // ubfx w9, w15, #2, #14 + WORD $0x1b107d29 // mul w9, w9, w16 + WORD $0x53117d29 // lsr w9, w9, #17 + WORD $0xd37ff92b // lsl x11, x9, #1 + WORD $0x1b11bd29 // msub w9, w9, w17, w15 + WORD $0x92403d29 // and x9, x9, #0xffff + WORD $0xd37ff929 // lsl x9, x9, #1 + WORD $0x5292cfef // mov w15, #38527 + WORD $0x72a0130f // movk w15, #152, lsl #16 + WORD $0x6b0f015f // cmp w10, w15 + WORD $0x54000c69 // b.ls LBB0_33 $396(%rip) +Lloh24: + WORD $0x100038aa // adr x10, _Digits $1812(%rip) +Lloh25: + WORD $0x9100014a // add x10, x10, _Digits@PAGEOFF $0(%rip) + WORD $0x386d694a // ldrb w10, [x10, x13] + WORD $0x3900010a // strb w10, [x8] + WORD $0x5280002a // mov w10, #1 + WORD $0x14000060 // b LBB0_35 $384(%rip) +LBB0_31: + WORD $0xd2adf829 // mov x9, #1874919424 + WORD $0xf2d0de49 // movk x9, #34546, lsl #32 + WORD $0xf2e00469 // movk x9, #35, lsl #48 + WORD $0xeb09003f // cmp x1, x9 + WORD $0x54001c42 // b.hs LBB0_41 $904(%rip) + WORD $0x9ac80829 // udiv x9, x1, x8 + WORD $0x1b088528 // msub w8, w9, w8, w1 + WORD $0x6f00e400 // movi.2d v0, #0000000000000000 + WORD $0x6f00e401 // movi.2d v1, #0000000000000000 + WORD $0x4e041d21 // mov.s v1[0], w9 + WORD $0x0ea12822 // xtn.2s v2, v1 + WORD $0x5282eb29 // mov w9, #5977 + WORD $0x72ba36e9 // movk w9, #53687, lsl #16 + WORD $0x0e040d23 // dup.2s v3, w9 + WORD $0x2ea3c042 // umull.2d v2, v2, v3 + WORD $0x6f530442 // ushr.2d v2, v2, #45 + WORD $0x0ea12844 // xtn.2s v4, v2 + WORD $0x5284e209 // mov w9, #10000 + WORD $0x0e040d25 // dup.2s v5, w9 + WORD $0x2ea5c084 // umull.2d v4, v4, v5 + WORD $0x6ea48421 // sub.4s v1, v1, v4 + WORD $0x4e413841 // zip1.8h v1, v2, v1 + WORD $0x4f425421 // shl.2d v1, v1, #2 + WORD $0x4e413821 // zip1.8h v1, v1, v1 + WORD $0x4e813821 // zip1.4s v1, v1, v1 +Lloh26: + WORD $0x10ffde69 // adr x9, lCPI0_0 $-1076(%rip) +Lloh27: + WORD $0xfd400122 // ldr d2, [x9, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x2e62c024 // umull.4s v4, v1, v2 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e62c021 // umull.4s v1, v1, v2 + WORD $0x4e415881 // uzp2.8h v1, v4, v1 +Lloh28: + WORD $0x10ffdde9 // adr x9, lCPI0_1 $-1092(%rip) +Lloh29: + WORD $0xfd400124 // ldr d4, [x9, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x2e64c026 // umull.4s v6, v1, v4 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e64c021 // umull.4s v1, v1, v4 + WORD $0x4e4158c1 // uzp2.8h v1, v6, v1 + WORD $0x4f008546 // movi.8h v6, #10 + WORD $0x4e669c27 // mul.8h v7, v1, v6 + WORD $0x4f5054e7 // shl.2d v7, v7, #16 + WORD $0x6e678421 // sub.8h v1, v1, v7 + WORD $0x4e041d00 // mov.s v0[0], w8 + WORD $0x0ea12807 // xtn.2s v7, v0 + WORD $0x2ea3c0e3 // umull.2d v3, v7, v3 + WORD $0x6f530463 // ushr.2d v3, v3, #45 + WORD $0x0ea12867 // xtn.2s v7, v3 + WORD $0x2ea5c0e5 // umull.2d v5, v7, v5 + WORD $0x6ea58400 // sub.4s v0, v0, v5 + WORD $0x4e403860 // zip1.8h v0, v3, v0 + WORD $0x4f425400 // shl.2d v0, v0, #2 + WORD $0x4e403800 // zip1.8h v0, v0, v0 + WORD $0x4e803800 // zip1.4s v0, v0, v0 + WORD $0x2e62c003 // umull.4s v3, v0, v2 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e62c000 // umull.4s v0, v0, v2 + WORD $0x4e405860 // uzp2.8h v0, v3, v0 + WORD $0x2e64c002 // umull.4s v2, v0, v4 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e64c000 // umull.4s v0, v0, v4 + WORD $0x4e405840 // uzp2.8h v0, v2, v0 + WORD $0x4e669c02 // mul.8h v2, v0, v6 + WORD $0x4f505442 // shl.2d v2, v2, #16 + WORD $0x6e628400 // sub.8h v0, v0, v2 + WORD $0x2e212821 // sqxtun.8b v1, v1 + WORD $0x6e212801 // sqxtun2.16b v1, v0 + WORD $0x4f01e600 // movi.16b v0, #48 + WORD $0x4e208420 // add.16b v0, v1, v0 + WORD $0x4e209821 // cmeq.16b v1, v1, #0 +Lloh30: + WORD $0x10ffd988 // adr x8, lCPI0_2 $-1232(%rip) +Lloh31: + WORD $0x3dc00102 // ldr q2, [x8, lCPI0_2@PAGEOFF] $0(%rip) + WORD $0x4e221c21 // and.16b v1, v1, v2 +Lloh32: + WORD $0x10ffd9a8 // adr x8, lCPI0_3 $-1228(%rip) +Lloh33: + WORD $0x3dc00102 // ldr q2, [x8, lCPI0_3@PAGEOFF] $0(%rip) + WORD $0x4e020021 // tbl.16b v1, { v1 }, v2 + WORD $0x4e71b821 // addv.8h h1, v1 + WORD $0x1e260028 // fmov w8, s1 + WORD $0x2a2803e8 // mvn w8, w8 + WORD $0x32114108 // orr w8, w8, #0xffff8000 + WORD $0x5ac00108 // rbit w8, w8 + WORD $0x5ac01108 // clz w8, w8 +Lloh34: + WORD $0x10003489 // adr x9, _VecShiftShuffles $1680(%rip) +Lloh35: + WORD $0x91000129 // add x9, x9, _VecShiftShuffles@PAGEOFF $0(%rip) + WORD $0x3ce85921 // ldr q1, [x9, w8, uxtw #4] + WORD $0x4f04e5e2 // movi.16b v2, #143 + WORD $0x4e221c21 // and.16b v1, v1, v2 + WORD $0x4e010000 // tbl.16b v0, { v0 }, v1 + WORD $0x3d800000 // str q0, [x0] + WORD $0x52800209 // mov w9, #16 + WORD $0x4b080128 // sub w8, w9, w8 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_33: + WORD $0x6b0e015f // cmp w10, w14 + WORD $0x540004c9 // b.ls LBB0_38 $152(%rip) + WORD $0x5280000a // mov w10, #0 +LBB0_35: + WORD $0x2a0d03ed // mov w13, w13 +Lloh36: + WORD $0x10002bee // adr x14, _Digits $1404(%rip) +Lloh37: + WORD $0x910001ce // add x14, x14, _Digits@PAGEOFF $0(%rip) + WORD $0xb24001ad // orr x13, x13, #0x1 + WORD $0x386d69cd // ldrb w13, [x14, x13] + WORD $0x1100054e // add w14, w10, #1 + WORD $0x382a490d // strb w13, [x8, w10, uxtw] +LBB0_36: +Lloh38: + WORD $0x10002b2a // adr x10, _Digits $1380(%rip) +Lloh39: + WORD $0x9100014a // add x10, x10, _Digits@PAGEOFF $0(%rip) + WORD $0x386c694a // ldrb w10, [x10, x12] + WORD $0x110005cd // add w13, w14, #1 + WORD $0x382e490a // strb w10, [x8, w14, uxtw] +LBB0_37: + WORD $0x3200018a // orr w10, w12, #0x1 + WORD $0x92403d4a // and x10, x10, #0xffff +Lloh40: + WORD $0x10002a4c // adr x12, _Digits $1352(%rip) +Lloh41: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0x386a698a // ldrb w10, [x12, x10] + WORD $0x8b2d4108 // add x8, x8, w13, uxtw + WORD $0x3900010a // strb w10, [x8] + WORD $0x386b698a // ldrb w10, [x12, x11] + WORD $0x3900050a // strb w10, [x8, #1] + WORD $0x2a0b03ea // mov w10, w11 + WORD $0xb240014a // orr x10, x10, #0x1 + WORD $0x386a698a // ldrb w10, [x12, x10] + WORD $0x3900090a // strb w10, [x8, #2] + WORD $0x3869698a // ldrb w10, [x12, x9] + WORD $0x39000d0a // strb w10, [x8, #3] + WORD $0x32000129 // orr w9, w9, #0x1 + WORD $0x92403d29 // and x9, x9, #0xffff + WORD $0x3869698a // ldrb w10, [x12, x9] + WORD $0x110015a9 // add w9, w13, #5 + WORD $0x3900110a // strb w10, [x8, #4] + WORD $0x11000528 // add w8, w9, #1 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_38: + WORD $0x5280000e // mov w14, #0 + WORD $0x5280000d // mov w13, #0 + WORD $0x53057d4a // lsr w10, w10, #5 + WORD $0x7130d55f // cmp w10, #3125 + WORD $0x54fffbe2 // b.hs LBB0_36 $-132(%rip) + WORD $0x17ffffe3 // b LBB0_37 $-116(%rip) +LBB0_39: + WORD $0xd2adf82c // mov x12, #1874919424 + WORD $0xf2d0de4c // movk x12, #34546, lsl #32 + WORD $0xf2e0046c // movk x12, #35, lsl #48 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x540018a2 // b.hs LBB0_47 $788(%rip) + WORD $0x9ac9094b // udiv x11, x10, x9 + WORD $0x1b09a969 // msub w9, w11, w9, w10 + WORD $0x6f00e400 // movi.2d v0, #0000000000000000 + WORD $0x6f00e401 // movi.2d v1, #0000000000000000 + WORD $0x4e041d61 // mov.s v1[0], w11 + WORD $0x0ea12822 // xtn.2s v2, v1 + WORD $0x5282eb2a // mov w10, #5977 + WORD $0x72ba36ea // movk w10, #53687, lsl #16 + WORD $0x0e040d43 // dup.2s v3, w10 + WORD $0x2ea3c042 // umull.2d v2, v2, v3 + WORD $0x6f530442 // ushr.2d v2, v2, #45 + WORD $0x0ea12844 // xtn.2s v4, v2 + WORD $0x5284e20a // mov w10, #10000 + WORD $0x0e040d45 // dup.2s v5, w10 + WORD $0x2ea5c084 // umull.2d v4, v4, v5 + WORD $0x6ea48421 // sub.4s v1, v1, v4 + WORD $0x4e413841 // zip1.8h v1, v2, v1 + WORD $0x4f425421 // shl.2d v1, v1, #2 + WORD $0x4e413821 // zip1.8h v1, v1, v1 + WORD $0x4e813821 // zip1.4s v1, v1, v1 +Lloh42: + WORD $0x10ffcd4a // adr x10, lCPI0_0 $-1624(%rip) +Lloh43: + WORD $0xfd400142 // ldr d2, [x10, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x2e62c024 // umull.4s v4, v1, v2 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e62c021 // umull.4s v1, v1, v2 + WORD $0x4e415881 // uzp2.8h v1, v4, v1 +Lloh44: + WORD $0x10ffccca // adr x10, lCPI0_1 $-1640(%rip) +Lloh45: + WORD $0xfd400144 // ldr d4, [x10, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x2e64c026 // umull.4s v6, v1, v4 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e64c021 // umull.4s v1, v1, v4 + WORD $0x4e4158c1 // uzp2.8h v1, v6, v1 + WORD $0x4f008546 // movi.8h v6, #10 + WORD $0x4e669c27 // mul.8h v7, v1, v6 + WORD $0x4f5054e7 // shl.2d v7, v7, #16 + WORD $0x6e678421 // sub.8h v1, v1, v7 + WORD $0x4e041d20 // mov.s v0[0], w9 + WORD $0x0ea12807 // xtn.2s v7, v0 + WORD $0x2ea3c0e3 // umull.2d v3, v7, v3 + WORD $0x6f530463 // ushr.2d v3, v3, #45 + WORD $0x0ea12867 // xtn.2s v7, v3 + WORD $0x2ea5c0e5 // umull.2d v5, v7, v5 + WORD $0x6ea58400 // sub.4s v0, v0, v5 + WORD $0x4e403860 // zip1.8h v0, v3, v0 + WORD $0x4f425400 // shl.2d v0, v0, #2 + WORD $0x4e403800 // zip1.8h v0, v0, v0 + WORD $0x4e803800 // zip1.4s v0, v0, v0 + WORD $0x2e62c003 // umull.4s v3, v0, v2 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e62c000 // umull.4s v0, v0, v2 + WORD $0x4e405860 // uzp2.8h v0, v3, v0 + WORD $0x2e64c002 // umull.4s v2, v0, v4 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e64c000 // umull.4s v0, v0, v4 + WORD $0x4e405840 // uzp2.8h v0, v2, v0 + WORD $0x4e669c02 // mul.8h v2, v0, v6 + WORD $0x4f505442 // shl.2d v2, v2, #16 + WORD $0x6e628400 // sub.8h v0, v0, v2 + WORD $0x2e212821 // sqxtun.8b v1, v1 + WORD $0x6e212801 // sqxtun2.16b v1, v0 + WORD $0x4f01e600 // movi.16b v0, #48 + WORD $0x4e208420 // add.16b v0, v1, v0 + WORD $0x4e209821 // cmeq.16b v1, v1, #0 +Lloh46: + WORD $0x10ffc869 // adr x9, lCPI0_2 $-1780(%rip) +Lloh47: + WORD $0x3dc00122 // ldr q2, [x9, lCPI0_2@PAGEOFF] $0(%rip) + WORD $0x4e221c21 // and.16b v1, v1, v2 +Lloh48: + WORD $0x10ffc889 // adr x9, lCPI0_3 $-1776(%rip) +Lloh49: + WORD $0x3dc00122 // ldr q2, [x9, lCPI0_3@PAGEOFF] $0(%rip) + WORD $0x4e020021 // tbl.16b v1, { v1 }, v2 + WORD $0x4e71b821 // addv.8h h1, v1 + WORD $0x1e260029 // fmov w9, s1 + WORD $0x2a2903e9 // mvn w9, w9 + WORD $0x32114129 // orr w9, w9, #0xffff8000 + WORD $0x5ac00129 // rbit w9, w9 + WORD $0x5ac01129 // clz w9, w9 +Lloh50: + WORD $0x1000236a // adr x10, _VecShiftShuffles $1132(%rip) +Lloh51: + WORD $0x9100014a // add x10, x10, _VecShiftShuffles@PAGEOFF $0(%rip) + WORD $0x3ce95941 // ldr q1, [x10, w9, uxtw #4] + WORD $0x4f04e5e2 // movi.16b v2, #143 + WORD $0x4e221c21 // and.16b v1, v1, v2 + WORD $0x4e010000 // tbl.16b v0, { v0 }, v1 + WORD $0x3d800100 // str q0, [x8] + WORD $0x52800208 // mov w8, #16 + WORD $0x4b090109 // sub w9, w8, w9 + WORD $0x11000528 // add w8, w9, #1 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_41: + WORD $0x9ac9082a // udiv x10, x1, x9 + WORD $0x9b098549 // msub x9, x10, x9, x1 + WORD $0x7100255f // cmp w10, #9 + WORD $0x540000a8 // b.hi LBB0_43 $20(%rip) + WORD $0x1100c14a // add w10, w10, #48 + WORD $0x3900000a // strb w10, [x0] + WORD $0x5280002a // mov w10, #1 + WORD $0x14000022 // b LBB0_46 $136(%rip) +LBB0_43: + WORD $0x71018d5f // cmp w10, #99 + WORD $0x540001a8 // b.hi LBB0_45 $52(%rip) + WORD $0x2a0a03ea // mov w10, w10 + WORD $0xd37ff94a // lsl x10, x10, #1 +Lloh52: + WORD $0x100019ab // adr x11, _Digits $820(%rip) +Lloh53: + WORD $0x9100016b // add x11, x11, _Digits@PAGEOFF $0(%rip) + WORD $0x386a696c // ldrb w12, [x11, x10] + WORD $0x3900000c // strb w12, [x0] + WORD $0x927f794a // and x10, x10, #0xfffffffe + WORD $0x8b0a016a // add x10, x11, x10 + WORD $0x3940054a // ldrb w10, [x10, #1] + WORD $0x3900040a // strb w10, [x0, #1] + WORD $0x5280004a // mov w10, #2 + WORD $0x14000014 // b LBB0_46 $80(%rip) +LBB0_45: + WORD $0x53023d4b // ubfx w11, w10, #2, #14 + WORD $0x52828f6c // mov w12, #5243 + WORD $0x1b0c7d6b // mul w11, w11, w12 + WORD $0x53117d6b // lsr w11, w11, #17 + WORD $0x1100c16c // add w12, w11, #48 + WORD $0x3900000c // strb w12, [x0] + WORD $0x52800c8c // mov w12, #100 + WORD $0x1b0ca96a // msub w10, w11, w12, w10 + WORD $0x92403d4a // and x10, x10, #0xffff + WORD $0xd37ff94a // lsl x10, x10, #1 +Lloh54: + WORD $0x1000172b // adr x11, _Digits $740(%rip) +Lloh55: + WORD $0x9100016b // add x11, x11, _Digits@PAGEOFF $0(%rip) + WORD $0x386a696c // ldrb w12, [x11, x10] + WORD $0x3900040c // strb w12, [x0, #1] + WORD $0x927f394a // and x10, x10, #0xfffe + WORD $0x8b0a016a // add x10, x11, x10 + WORD $0x3940054a // ldrb w10, [x10, #1] + WORD $0x3900080a // strb w10, [x0, #2] + WORD $0x5280006a // mov w10, #3 +LBB0_46: + WORD $0x9ac8092b // udiv x11, x9, x8 + WORD $0x6f00e400 // movi.2d v0, #0000000000000000 + WORD $0x6f00e401 // movi.2d v1, #0000000000000000 + WORD $0x4e041d61 // mov.s v1[0], w11 + WORD $0x5282eb2c // mov w12, #5977 + WORD $0x72ba36ec // movk w12, #53687, lsl #16 + WORD $0x0e040d82 // dup.2s v2, w12 + WORD $0x0ea12823 // xtn.2s v3, v1 + WORD $0x2ea2c063 // umull.2d v3, v3, v2 + WORD $0x6f530463 // ushr.2d v3, v3, #45 + WORD $0x5284e20c // mov w12, #10000 + WORD $0x0e040d84 // dup.2s v4, w12 + WORD $0x0ea12865 // xtn.2s v5, v3 + WORD $0x2ea4c0a5 // umull.2d v5, v5, v4 + WORD $0x6ea58421 // sub.4s v1, v1, v5 + WORD $0x4e413861 // zip1.8h v1, v3, v1 + WORD $0x4f425421 // shl.2d v1, v1, #2 + WORD $0x4e413821 // zip1.8h v1, v1, v1 + WORD $0x4e813821 // zip1.4s v1, v1, v1 +Lloh56: + WORD $0x10ffbd4c // adr x12, lCPI0_0 $-2136(%rip) +Lloh57: + WORD $0xfd400183 // ldr d3, [x12, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x2e63c025 // umull.4s v5, v1, v3 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e63c021 // umull.4s v1, v1, v3 + WORD $0x4e4158a1 // uzp2.8h v1, v5, v1 +Lloh58: + WORD $0x10ffbccc // adr x12, lCPI0_1 $-2152(%rip) +Lloh59: + WORD $0xfd400185 // ldr d5, [x12, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x2e65c026 // umull.4s v6, v1, v5 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e65c021 // umull.4s v1, v1, v5 + WORD $0x4e4158c1 // uzp2.8h v1, v6, v1 + WORD $0x4f008546 // movi.8h v6, #10 + WORD $0x4e669c27 // mul.8h v7, v1, v6 + WORD $0x4f5054e7 // shl.2d v7, v7, #16 + WORD $0x6e678421 // sub.8h v1, v1, v7 + WORD $0x1b08a568 // msub w8, w11, w8, w9 + WORD $0x4e041d00 // mov.s v0[0], w8 + WORD $0x0ea12807 // xtn.2s v7, v0 + WORD $0x2ea2c0e2 // umull.2d v2, v7, v2 + WORD $0x6f530442 // ushr.2d v2, v2, #45 + WORD $0x0ea12847 // xtn.2s v7, v2 + WORD $0x2ea4c0e4 // umull.2d v4, v7, v4 + WORD $0x6ea48400 // sub.4s v0, v0, v4 + WORD $0x4e403840 // zip1.8h v0, v2, v0 + WORD $0x4f425400 // shl.2d v0, v0, #2 + WORD $0x4e403800 // zip1.8h v0, v0, v0 + WORD $0x4e803800 // zip1.4s v0, v0, v0 + WORD $0x2e63c002 // umull.4s v2, v0, v3 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e63c000 // umull.4s v0, v0, v3 + WORD $0x4e405840 // uzp2.8h v0, v2, v0 + WORD $0x2e65c002 // umull.4s v2, v0, v5 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e65c000 // umull.4s v0, v0, v5 + WORD $0x4e405840 // uzp2.8h v0, v2, v0 + WORD $0x4e669c02 // mul.8h v2, v0, v6 + WORD $0x4f505442 // shl.2d v2, v2, #16 + WORD $0x6e628400 // sub.8h v0, v0, v2 + WORD $0x2e212821 // sqxtun.8b v1, v1 + WORD $0x6e212801 // sqxtun2.16b v1, v0 + WORD $0x4f01e600 // movi.16b v0, #48 + WORD $0x4e208420 // add.16b v0, v1, v0 + WORD $0x3caa4800 // str q0, [x0, w10, uxtw] + WORD $0x321c0148 // orr w8, w10, #0x10 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_47: + WORD $0x9acc094b // udiv x11, x10, x12 + WORD $0x9b0ca96a // msub x10, x11, x12, x10 + WORD $0x7100257f // cmp w11, #9 + WORD $0x540000a8 // b.hi LBB0_49 $20(%rip) + WORD $0x1100c16b // add w11, w11, #48 + WORD $0x3900010b // strb w11, [x8] + WORD $0x5280002b // mov w11, #1 + WORD $0x14000022 // b LBB0_52 $136(%rip) +LBB0_49: + WORD $0x71018d7f // cmp w11, #99 + WORD $0x540001a8 // b.hi LBB0_51 $52(%rip) + WORD $0x2a0b03eb // mov w11, w11 + WORD $0xd37ff96b // lsl x11, x11, #1 +Lloh60: + WORD $0x10000c2c // adr x12, _Digits $388(%rip) +Lloh61: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0x386b698d // ldrb w13, [x12, x11] + WORD $0x3900040d // strb w13, [x0, #1] + WORD $0x927f796b // and x11, x11, #0xfffffffe + WORD $0x8b0b018b // add x11, x12, x11 + WORD $0x3940056b // ldrb w11, [x11, #1] + WORD $0x3900080b // strb w11, [x0, #2] + WORD $0x5280004b // mov w11, #2 + WORD $0x14000014 // b LBB0_52 $80(%rip) +LBB0_51: + WORD $0x53023d6c // ubfx w12, w11, #2, #14 + WORD $0x52828f6d // mov w13, #5243 + WORD $0x1b0d7d8c // mul w12, w12, w13 + WORD $0x53117d8c // lsr w12, w12, #17 + WORD $0x1100c18d // add w13, w12, #48 + WORD $0x3900040d // strb w13, [x0, #1] + WORD $0x52800c8d // mov w13, #100 + WORD $0x1b0dad8b // msub w11, w12, w13, w11 + WORD $0x92403d6b // and x11, x11, #0xffff + WORD $0xd37ff96b // lsl x11, x11, #1 +Lloh62: + WORD $0x100009ac // adr x12, _Digits $308(%rip) +Lloh63: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0x386b698d // ldrb w13, [x12, x11] + WORD $0x3900080d // strb w13, [x0, #2] + WORD $0x927f396b // and x11, x11, #0xfffe + WORD $0x8b0b018b // add x11, x12, x11 + WORD $0x3940056b // ldrb w11, [x11, #1] + WORD $0x39000c0b // strb w11, [x0, #3] + WORD $0x5280006b // mov w11, #3 +LBB0_52: + WORD $0x9ac9094c // udiv x12, x10, x9 + WORD $0x6f00e400 // movi.2d v0, #0000000000000000 + WORD $0x6f00e401 // movi.2d v1, #0000000000000000 + WORD $0x4e041d81 // mov.s v1[0], w12 + WORD $0x5282eb2d // mov w13, #5977 + WORD $0x72ba36ed // movk w13, #53687, lsl #16 + WORD $0x0e040da2 // dup.2s v2, w13 + WORD $0x0ea12823 // xtn.2s v3, v1 + WORD $0x2ea2c063 // umull.2d v3, v3, v2 + WORD $0x6f530463 // ushr.2d v3, v3, #45 + WORD $0x5284e20d // mov w13, #10000 + WORD $0x0e040da4 // dup.2s v4, w13 + WORD $0x0ea12865 // xtn.2s v5, v3 + WORD $0x2ea4c0a5 // umull.2d v5, v5, v4 + WORD $0x6ea58421 // sub.4s v1, v1, v5 + WORD $0x4e413861 // zip1.8h v1, v3, v1 + WORD $0x4f425421 // shl.2d v1, v1, #2 + WORD $0x4e413821 // zip1.8h v1, v1, v1 + WORD $0x4e813821 // zip1.4s v1, v1, v1 +Lloh64: + WORD $0x10ffafcd // adr x13, lCPI0_0 $-2568(%rip) +Lloh65: + WORD $0xfd4001a3 // ldr d3, [x13, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x2e63c025 // umull.4s v5, v1, v3 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e63c021 // umull.4s v1, v1, v3 + WORD $0x4e4158a1 // uzp2.8h v1, v5, v1 +Lloh66: + WORD $0x10ffaf4d // adr x13, lCPI0_1 $-2584(%rip) +Lloh67: + WORD $0xfd4001a5 // ldr d5, [x13, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x2e65c026 // umull.4s v6, v1, v5 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e65c021 // umull.4s v1, v1, v5 + WORD $0x4e4158c1 // uzp2.8h v1, v6, v1 + WORD $0x4f008546 // movi.8h v6, #10 + WORD $0x4e669c27 // mul.8h v7, v1, v6 + WORD $0x4f5054e7 // shl.2d v7, v7, #16 + WORD $0x6e678421 // sub.8h v1, v1, v7 + WORD $0x1b09a989 // msub w9, w12, w9, w10 + WORD $0x4e041d20 // mov.s v0[0], w9 + WORD $0x0ea12807 // xtn.2s v7, v0 + WORD $0x2ea2c0e2 // umull.2d v2, v7, v2 + WORD $0x6f530442 // ushr.2d v2, v2, #45 + WORD $0x0ea12847 // xtn.2s v7, v2 + WORD $0x2ea4c0e4 // umull.2d v4, v7, v4 + WORD $0x6ea48400 // sub.4s v0, v0, v4 + WORD $0x4e403840 // zip1.8h v0, v2, v0 + WORD $0x4f425400 // shl.2d v0, v0, #2 + WORD $0x4e403800 // zip1.8h v0, v0, v0 + WORD $0x4e803800 // zip1.4s v0, v0, v0 + WORD $0x2e63c002 // umull.4s v2, v0, v3 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e63c000 // umull.4s v0, v0, v3 + WORD $0x4e405840 // uzp2.8h v0, v2, v0 + WORD $0x2e65c002 // umull.4s v2, v0, v5 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e65c000 // umull.4s v0, v0, v5 + WORD $0x4e405840 // uzp2.8h v0, v2, v0 + WORD $0x4e669c02 // mul.8h v2, v0, v6 + WORD $0x4f505442 // shl.2d v2, v2, #16 + WORD $0x6e628400 // sub.8h v0, v0, v2 + WORD $0x2e212821 // sqxtun.8b v1, v1 + WORD $0x6e212801 // sqxtun2.16b v1, v0 + WORD $0x4f01e600 // movi.16b v0, #48 + WORD $0x4e208420 // add.16b v0, v1, v0 + WORD $0x3cab4900 // str q0, [x8, w11, uxtw] + WORD $0x321c0169 // orr w9, w11, #0x10 + WORD $0x11000528 // add w8, w9, #1 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +_Digits: + WORD $0x31303030 // .ascii 4, '0001020304050607' + WORD $0x33303230 // .ascii 4, '0203040506070809' + WORD $0x35303430 // .ascii 4, '0405060708091011' + WORD $0x37303630 // .ascii 4, '0607080910111213' + WORD $0x39303830 // .ascii 4, '0809101112131415' + WORD $0x31313031 // .ascii 4, '1011121314151617' + WORD $0x33313231 // .ascii 4, '1213141516171819' + WORD $0x35313431 // .ascii 4, '1415161718192021' + WORD $0x37313631 // .ascii 4, '1617181920212223' + WORD $0x39313831 // .ascii 4, '1819202122232425' + WORD $0x31323032 // .ascii 4, '2021222324252627' + WORD $0x33323232 // .ascii 4, '2223242526272829' + WORD $0x35323432 // .ascii 4, '2425262728293031' + WORD $0x37323632 // .ascii 4, '2627282930313233' + WORD $0x39323832 // .ascii 4, '2829303132333435' + WORD $0x31333033 // .ascii 4, '3031323334353637' + WORD $0x33333233 // .ascii 4, '3233343536373839' + WORD $0x35333433 // .ascii 4, '3435363738394041' + WORD $0x37333633 // .ascii 4, '3637383940414243' + WORD $0x39333833 // .ascii 4, '3839404142434445' + WORD $0x31343034 // .ascii 4, '4041424344454647' + WORD $0x33343234 // .ascii 4, '4243444546474849' + WORD $0x35343434 // .ascii 4, '4445464748495051' + WORD $0x37343634 // .ascii 4, '4647484950515253' + WORD $0x39343834 // .ascii 4, '4849505152535455' + WORD $0x31353035 // .ascii 4, '5051525354555657' + WORD $0x33353235 // .ascii 4, '5253545556575859' + WORD $0x35353435 // .ascii 4, '5455565758596061' + WORD $0x37353635 // .ascii 4, '5657585960616263' + WORD $0x39353835 // .ascii 4, '5859606162636465' + WORD $0x31363036 // .ascii 4, '6061626364656667' + WORD $0x33363236 // .ascii 4, '6263646566676869' + WORD $0x35363436 // .ascii 4, '6465666768697071' + WORD $0x37363636 // .ascii 4, '6667686970717273' + WORD $0x39363836 // .ascii 4, '6869707172737475' + WORD $0x31373037 // .ascii 4, '7071727374757677' + WORD $0x33373237 // .ascii 4, '7273747576777879' + WORD $0x35373437 // .ascii 4, '7475767778798081' + WORD $0x37373637 // .ascii 4, '7677787980818283' + WORD $0x39373837 // .ascii 4, '7879808182838485' + WORD $0x31383038 // .ascii 4, '8081828384858687' + WORD $0x33383238 // .ascii 4, '8283848586878889' + WORD $0x35383438 // .ascii 4, '8485868788899091' + WORD $0x37383638 // .ascii 4, '8687888990919293' + WORD $0x39383838 // .ascii 4, '8889909192939495' + WORD $0x31393039 // .ascii 4, '9091929394959697' + WORD $0x33393239 // .ascii 4, '9293949596979899' + WORD $0x35393439 // .ascii 4, '949596979899' + WORD $0x37393639 // .ascii 4, '96979899' + WORD $0x39393839 // .ascii 4, '9899' + WORD $0x00000000; WORD $0x00000000; WORD $0x00000000 // .p2align 4, 0x00 +_VecShiftShuffles: + WORD $0x03020100 // .ascii 4, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' + WORD $0x07060504 // .ascii 4, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x01\x02\x03\x04' + WORD $0x0b0a0908 // .ascii 4, '\x08\t\n\x0b\x0c\r\x0e\x0f\x01\x02\x03\x04\x05\x06\x07\x08' + WORD $0x0f0e0d0c // .ascii 4, '\x0c\r\x0e\x0f\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c' + WORD $0x04030201 // .ascii 4, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff' + WORD $0x08070605 // .ascii 4, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\x02\x03\x04\x05' + WORD $0x0c0b0a09 // .ascii 4, '\t\n\x0b\x0c\r\x0e\x0f\xff\x02\x03\x04\x05\x06\x07\x08\t' + WORD $0xff0f0e0d // .ascii 4, '\r\x0e\x0f\xff\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r' + WORD $0x05040302 // .ascii 4, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff' + WORD $0x09080706 // .ascii 4, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\x03\x04\x05\x06' + WORD $0x0d0c0b0a // .ascii 4, '\n\x0b\x0c\r\x0e\x0f\xff\xff\x03\x04\x05\x06\x07\x08\t\n' + WORD $0xffff0f0e // .ascii 4, '\x0e\x0f\xff\xff\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e' + WORD $0x06050403 // .ascii 4, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff' + WORD $0x0a090807 // .ascii 4, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\x04\x05\x06\x07' + WORD $0x0e0d0c0b // .ascii 4, '\x0b\x0c\r\x0e\x0f\xff\xff\xff\x04\x05\x06\x07\x08\t\n\x0b' + WORD $0xffffff0f // .ascii 4, '\x0f\xff\xff\xff\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' + WORD $0x07060504 // .ascii 4, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff' + WORD $0x0b0a0908 // .ascii 4, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\x05\x06\x07\x08' + WORD $0x0f0e0d0c // .ascii 4, '\x0c\r\x0e\x0f\xff\xff\xff\xff\x05\x06\x07\x08\t\n\x0b\x0c' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff' + WORD $0x08070605 // .ascii 4, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff' + WORD $0x0c0b0a09 // .ascii 4, '\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\x06\x07\x08\t' + WORD $0xff0f0e0d // .ascii 4, '\r\x0e\x0f\xff\xff\xff\xff\xff\x06\x07\x08\t\n\x0b\x0c\r' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff' + WORD $0x09080706 // .ascii 4, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff' + WORD $0x0d0c0b0a // .ascii 4, '\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\x07\x08\t\n' + WORD $0xffff0f0e // .ascii 4, '\x0e\x0f\xff\xff\xff\xff\xff\xff\x07\x08\t\n\x0b\x0c\r\x0e' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff' + WORD $0x0a090807 // .ascii 4, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff' + WORD $0x0e0d0c0b // .ascii 4, '\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\x08\t\n\x0b' + WORD $0xffffff0f // .ascii 4, '\x0f\xff\xff\xff\xff\xff\xff\xff\x08\t\n\x0b\x0c\r\x0e\x0f' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff' + WORD $0x0b0a0908 // .ascii 4, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff' + WORD $0x0f0e0d0c // .ascii 4, '\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff\xff\xff\xff\xff' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff' + +TEXT ·__i64toa(SB), $0-24 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $64, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_i64toa: + MOVD out+0(FP), R0 + MOVD val+8(FP), R1 + CALL ·__i64toa_arm64_entry__+76(SB) // _i64toa + MOVD R0, ret+16(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/i64toa_subr_arm64.go b/internal/native/neon/i64toa_subr_arm64.go new file mode 100644 index 000000000..4d5d21c52 --- /dev/null +++ b/internal/native/neon/i64toa_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __i64toa_arm64_entry__() uintptr + +var ( + _subr__i64toa uintptr = __i64toa_arm64_entry__() + 64 +) + +const ( + _stack__i64toa = 32 +) + +var ( + _ = _subr__i64toa +) + +const ( + _ = _stack__i64toa +) diff --git a/internal/native/neon/lspace_arm64.go b/internal/native/neon/lspace_arm64.go new file mode 100644 index 000000000..e6af97109 --- /dev/null +++ b/internal/native/neon/lspace_arm64.go @@ -0,0 +1,37 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + `unsafe` + + // `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func lspace(sp unsafe.Pointer, nb int, off int) (ret int) { + return __lspace(sp, nb, off) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __lspace(sp unsafe.Pointer, nb int, off int) (ret int) diff --git a/internal/native/neon/lspace_arm64.s b/internal/native/neon/lspace_arm64.s new file mode 100644 index 000000000..5c613cffa --- /dev/null +++ b/internal/native/neon/lspace_arm64.s @@ -0,0 +1,62 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__lspace_arm64_entry__(SB), NOSPLIT, $16 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_lspace: + MOVD.W R30, -32(RSP) // WORD $0xf81e0ffe // str x30, [sp, #-32]! + WORD $0xeb02003f // cmp x1, x2 + WORD $0x540001e0 // b.eq LBB0_4 $60(%rip) + WORD $0x8b010008 // add x8, x0, x1 + WORD $0x52800029 // mov w9, #1 + WORD $0xd284c00a // mov x10, #9728 + WORD $0xf2c0002a // movk x10, #1, lsl #32 +LBB0_2: + WORD $0x38e2680b // ldrsb w11, [x0, x2] + WORD $0x7100817f // cmp w11, #32 + WORD $0x9acb212b // lsl x11, x9, x11 + WORD $0x8a0a016b // and x11, x11, x10 + WORD $0xfa409964 // ccmp x11, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_6 $28(%rip) + WORD $0x91000442 // add x2, x2, #1 + WORD $0xeb02003f // cmp x1, x2 + WORD $0x54ffff01 // b.ne LBB0_2 $-32(%rip) + WORD $0x14000002 // b LBB0_5 $8(%rip) +LBB0_4: + WORD $0x8b020008 // add x8, x0, x2 +LBB0_5: + WORD $0xcb000102 // sub x2, x8, x0 +LBB0_6: + WORD $0xaa0203e0 // mov x0, x2 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret + +TEXT ·__lspace(SB), $0-32 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $64, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_lspace: + MOVD sp+0(FP), R0 + MOVD nb+8(FP), R1 + MOVD off+16(FP), R2 + CALL ·__lspace_arm64_entry__+24(SB) // _lspace + MOVD R0, ret+24(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/lspace_subr_arm64.go b/internal/native/neon/lspace_subr_arm64.go new file mode 100644 index 000000000..4ecbe9672 --- /dev/null +++ b/internal/native/neon/lspace_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __lspace_arm64_entry__() uintptr + +var ( + _subr__lspace uintptr = __lspace_arm64_entry__() + 12 +) + +const ( + _stack__lspace = 32 +) + +var ( + _ = _subr__lspace +) + +const ( + _ = _stack__lspace +) diff --git a/internal/native/neon/native_arm64_test.go b/internal/native/neon/native_arm64_test.go new file mode 100644 index 000000000..df1246214 --- /dev/null +++ b/internal/native/neon/native_arm64_test.go @@ -0,0 +1,635 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + `encoding/hex` + `fmt` + `math` + `strings` + `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_SkipNumberInJson(t *testing.T) { + p := 0x13 + s := "{\"h\":\"1.00000\",\"i\":true,\"pass3\":1}" + q := skip_number(&s, &p) + assert.Equal(t, 0x13, p) + assert.Equal(t, -2, 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) + } +} + +func TestNative_GetByPath(t *testing.T) { + s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5` + p := 0 + path := []interface{}{"asdf", 4} + ret := get_by_path(&s, &p, &path, types.NewStateMachine()) + assert.Equal(t, strings.Index(s, "2.0"), ret) +} + +func BenchmarkNative_SkipOneFast(b *testing.B) { + b.ResetTimer() + for i:=0; i(SB) + JMP _entry diff --git a/internal/native/neon/quote_subr_arm64.go b/internal/native/neon/quote_subr_arm64.go new file mode 100644 index 000000000..c41cfd8ec --- /dev/null +++ b/internal/native/neon/quote_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __quote_arm64_entry__() uintptr + +var ( + _subr__quote uintptr = __quote_arm64_entry__() + 48 +) + +const ( + _stack__quote = 32 +) + +var ( + _ = _subr__quote +) + +const ( + _ = _stack__quote +) diff --git a/internal/native/neon/recover_arm64_test.go b/internal/native/neon/recover_arm64_test.go new file mode 100644 index 000000000..5a8f9e1ec --- /dev/null +++ b/internal/native/neon/recover_arm64_test.go @@ -0,0 +1,670 @@ +// Code generated by Makefile, DO NOT EDIT. + +/** + * 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 neon + +import ( + `os` + `runtime` + `runtime/debug` + `testing` + `time` + `unsafe` + + `github.com/bytedance/sonic/internal/native/types` +) + +var ( + debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == "" +) + +func TestMain(m *testing.M) { + go func () { + if !debugAsyncGC { + return + } + println("Begin GC looping...") + for { + runtime.GC() + debug.FreeOSMemory() + } + println("stop GC looping!") + }() + time.Sleep(time.Millisecond*100) + m.Run() +} + +func TestRecover_f64toa(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = f64toa(nil, 123) +} + +func TestRecover_f32toa(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = f32toa(nil, 123) +} + +func TestRecover_i64toa(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = i64toa(nil, 123) +} + +func TestRecover_u64toa(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = u64toa(nil, 123) +} + +func TestRecover_lspace(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = lspace(nil, 2, 0) +} + +func TestRecover_quote(t *testing.T) { + var dn = 10 + var dp = make([]byte, dn) + var sp = []byte("123") + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = quote(nil, 3, unsafe.Pointer(&dp[0]), &dn, 0) + }) + t.Run("dp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = quote(unsafe.Pointer(&sp[0]), 3, nil, &dn, 0) + }) + t.Run("dn", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = quote(unsafe.Pointer(&sp[0]), 3, unsafe.Pointer(&dp[0]), nil, 0) + }) +} + +func TestRecover_html_escape(t *testing.T) { + var dn = 10 + var dp = make([]byte, dn) + var sp = []byte("123") + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = html_escape(nil, 3, unsafe.Pointer(&dp[0]), &dn) + }) + t.Run("dp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = html_escape(unsafe.Pointer(&sp[0]), 3, nil, &dn) + }) + t.Run("dn", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = html_escape(unsafe.Pointer(&sp[0]), 3, unsafe.Pointer(&dp[0]), nil) + }) +} + +func TestRecover_unquote(t *testing.T) { + var ep = 0 + var dp = make([]byte, 10) + var sp = []byte("12\\x\"3\"4") + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = unquote(nil, len(sp), unsafe.Pointer(&dp[0]), &ep, 0) + }) + t.Run("dp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = unquote(unsafe.Pointer(&sp[0]), len(sp), nil, &ep, 0) + }) + t.Run("ep", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = unquote(unsafe.Pointer(&sp[0]), len(sp), unsafe.Pointer(&dp[0]), nil, 0) + }) +} + +func TestRecover_value(t *testing.T) { + var v = new(types.JsonState) + var sp = []byte("123") + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = value(nil, 3, 0, v, 0) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = value(unsafe.Pointer(&sp[0]), 3, 0, nil, 0) + }) +} + +func TestRecover_vstring(t *testing.T) { + var v = new(types.JsonState) + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vstring(nil, &p, v, 0) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vstring(&sp, nil, v, 0) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vstring(&sp, &p, nil, 0) + }) +} + +func TestRecover_vnumber(t *testing.T) { + var v = new(types.JsonState) + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vnumber(nil, &p, v) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vnumber(&sp, nil, v) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vnumber(&sp, &p, nil) + }) +} + +func TestRecover_vsigned(t *testing.T) { + var v = new(types.JsonState) + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vsigned(nil, &p, v) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vsigned(&sp, nil, v) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vsigned(&sp, &p, nil) + }) +} + +func TestRecover_vunsigned(t *testing.T) { + var v = new(types.JsonState) + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vunsigned(nil, &p, v) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vunsigned(&sp, nil, v) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vunsigned(&sp, &p, nil) + }) +} + +func TestRecover_skip_one(t *testing.T) { + var v = types.NewStateMachine() + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_one(nil, &p, v, 0) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_one(&sp, nil, v, 0) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_one(&sp, &p, nil, 0) + }) +} + +func TestRecover_skip_one_fast(t *testing.T) { + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_one_fast(nil, &p) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_one_fast(&sp, nil) + }) +} + +func TestRecover_skip_array(t *testing.T) { + var v = types.NewStateMachine() + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_array(nil, &p, v, 0) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_array(&sp, nil, v, 0) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_array(&sp, &p, nil, 0) + }) +} + +func TestRecover_skip_object(t *testing.T) { + var v = types.NewStateMachine() + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_object(nil, &p, v, 0) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_object(&sp, nil, v, 0) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_object(&sp, &p, nil, 0) + }) +} + +func TestRecover_skip_number(t *testing.T) { + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_number(nil, &p) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_number(&sp, nil) + }) +} + +func TestRecover_get_by_path(t *testing.T) { + var v = []interface{}{} + var sp = "123" + var p = 0 + var m = types.NewStateMachine() + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = get_by_path(nil, &p, &v, m) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = get_by_path(&sp, nil, &v, m) + }) + t.Run("path", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = get_by_path(&sp, &p, nil, m) + }) + t.Run("m", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = get_by_path(&sp, &p, &v, nil) + }) +} + +func TestRecover_validate_one(t *testing.T) { + var v = types.NewStateMachine() + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_one(nil, &p, v) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_one(&sp, nil, v) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_one(&sp, &p, nil) + }) +} + +func TestRecover_validate_utf8(t *testing.T) { + var v = types.NewStateMachine() + var sp = string([]byte{0xff, 0xff, 0xff}) + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_utf8(nil, &p, v) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_utf8(&sp, nil, v) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_utf8(&sp, &p, nil) + }) +} + +func TestRecover_validate_utf8_fast(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_utf8_fast(nil) +} diff --git a/internal/native/neon/skip_array_arm64.go b/internal/native/neon/skip_array_arm64.go new file mode 100644 index 000000000..f6ce31522 --- /dev/null +++ b/internal/native/neon/skip_array_arm64.go @@ -0,0 +1,37 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + // `unsafe` + + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) { + return __skip_array(s, p, m, flags) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) diff --git a/internal/native/neon/skip_array_arm64.s b/internal/native/neon/skip_array_arm64.s new file mode 100644 index 000000000..b33da3226 --- /dev/null +++ b/internal/native/neon/skip_array_arm64.s @@ -0,0 +1,2702 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__skip_array_arm64_entry__(SB), NOSPLIT, $144 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910283ff // add sp, sp, #160 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x00000001; WORD $0x00000000 // .quad 1 + WORD $0x00000005; WORD $0x00000000 // .quad 5 +lCPI0_1: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_2: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_skip_array: + MOVD.W R30, -160(RSP) // WORD $0xf8160ffe // str x30, [sp, #-160]! + WORD $0xa9046ffc // stp x28, x27, [sp, #64] + WORD $0xa90567fa // stp x26, x25, [sp, #80] + WORD $0xa9065ff8 // stp x24, x23, [sp, #96] + WORD $0xa90757f6 // stp x22, x21, [sp, #112] + WORD $0xa9084ff4 // stp x20, x19, [sp, #128] + WORD $0xa9097bfd // stp x29, x30, [sp, #144] + WORD $0xaa0003e6 // mov x6, x0 +Lloh0: + WORD $0x10fffd88 // adr x8, lCPI0_0 $-80(%rip) +Lloh1: + WORD $0x3dc00100 // ldr q0, [x8, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x3d800040 // str q0, [x2] + WORD $0xf9400009 // ldr x9, [x0] + WORD $0xaa2903e8 // mvn x8, x9 + WORD $0xf90013e8 // str x8, [sp, #32] + WORD $0x5280002b // mov w11, #1 + WORD $0xcb090168 // sub x8, x11, x9 + WORD $0xf90017e8 // str x8, [sp, #40] + WORD $0xf9400020 // ldr x0, [x1] + WORD $0xcb0903e8 // neg x8, x9 + WORD $0xf9001be8 // str x8, [sp, #48] + WORD $0xd1000528 // sub x8, x9, #1 + WORD $0xf9001fe8 // str x8, [sp, #56] + WORD $0x92800017 // mov x23, #-1 + WORD $0xd284c010 // mov x16, #9728 + WORD $0xf2c00030 // movk x16, #1, lsl #32 + WORD $0x4f01e440 // movi.16b v0, #34 + WORD $0x4f02e781 // movi.16b v1, #92 +Lloh2: + WORD $0x10fffba8 // adr x8, lCPI0_1 $-140(%rip) +Lloh3: + WORD $0x3dc00102 // ldr q2, [x8, lCPI0_1@PAGEOFF] $0(%rip) +Lloh4: + WORD $0x10fffbe8 // adr x8, lCPI0_2 $-132(%rip) +Lloh5: + WORD $0x3dc00103 // ldr q3, [x8, lCPI0_2@PAGEOFF] $0(%rip) + WORD $0x4f01e404 // movi.16b v4, #32 + WORD $0x4f01e5c5 // movi.16b v5, #46 + WORD $0x4f01e566 // movi.16b v6, #43 +Lloh6: + WORD $0x10010974 // adr x20, LJTI0_2 $8492(%rip) +Lloh7: + WORD $0x91000294 // add x20, x20, LJTI0_2@PAGEOFF $0(%rip) + WORD $0x12800015 // mov w21, #-1 + WORD $0x4f01e5a7 // movi.16b v7, #45 + WORD $0x4f06e610 // movi.16b v16, #208 +Lloh8: + WORD $0x100109b6 // adr x22, LJTI0_3 $8500(%rip) +Lloh9: + WORD $0x910002d6 // add x22, x22, LJTI0_3@PAGEOFF $0(%rip) + WORD $0x4f00e551 // movi.16b v17, #10 + WORD $0x4f06e7f2 // movi.16b v18, #223 + WORD $0x4f02e4b3 // movi.16b v19, #69 + WORD $0x52800039 // mov w25, #1 +Lloh10: + WORD $0x1000ffe4 // adr x4, LJTI0_0 $8188(%rip) +Lloh11: + WORD $0x91000084 // add x4, x4, LJTI0_0@PAGEOFF $0(%rip) + WORD $0x14000009 // b LBB0_4 $36(%rip) +LBB0_1: + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x5280008a // mov w10, #4 +LBB0_2: + WORD $0xf900050a // str x10, [x8, #8] +LBB0_3: + WORD $0xf9400059 // ldr x25, [x2] + WORD $0xaa1703ef // mov x15, x23 + WORD $0xb400f419 // cbz x25, LBB0_400 $7808(%rip) +LBB0_4: + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0f001f // cmp x0, x15 + WORD $0x54000162 // b.hs LBB0_9 $44(%rip) + WORD $0x38606928 // ldrb w8, [x9, x0] + WORD $0x7100351f // cmp w8, #13 + WORD $0x54000100 // b.eq LBB0_9 $32(%rip) + WORD $0x7100811f // cmp w8, #32 + WORD $0x540000c0 // b.eq LBB0_9 $24(%rip) + WORD $0x51002d08 // sub w8, w8, #11 + WORD $0x3100091f // cmn w8, #2 + WORD $0x54000062 // b.hs LBB0_9 $12(%rip) + WORD $0xaa0003e8 // mov x8, x0 + WORD $0x14000035 // b LBB0_29 $212(%rip) +LBB0_9: + WORD $0x91000408 // add x8, x0, #1 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_13 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_13 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_13 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x54000543 // b.lo LBB0_29 $168(%rip) +LBB0_13: + WORD $0x91000808 // add x8, x0, #2 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_17 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_17 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_17 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x540003e3 // b.lo LBB0_29 $124(%rip) +LBB0_17: + WORD $0x91000c08 // add x8, x0, #3 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_21 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_21 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_21 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x54000283 // b.lo LBB0_29 $80(%rip) +LBB0_21: + WORD $0x91001008 // add x8, x0, #4 + WORD $0xeb0801ff // cmp x15, x8 + WORD $0x5400ea69 // b.ls LBB0_386 $7500(%rip) + WORD $0x54000180 // b.eq LBB0_26 $48(%rip) + WORD $0x8b0f012a // add x10, x9, x15 +LBB0_24: + WORD $0x38e8692c // ldrsb w12, [x9, x8] + WORD $0x7100819f // cmp w12, #32 + WORD $0x9acc216c // lsl x12, x11, x12 + WORD $0x8a10018c // and x12, x12, x16 + WORD $0xfa409984 // ccmp x12, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_28 $28(%rip) + WORD $0x91000508 // add x8, x8, #1 + WORD $0xeb0801ff // cmp x15, x8 + WORD $0x54ffff01 // b.ne LBB0_24 $-32(%rip) + WORD $0x14000002 // b LBB0_27 $8(%rip) +LBB0_26: + WORD $0x8b08012a // add x10, x9, x8 +LBB0_27: + WORD $0xcb090148 // sub x8, x10, x9 +LBB0_28: + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x5400e882 // b.hs LBB0_387 $7440(%rip) +LBB0_29: + WORD $0x91000500 // add x0, x8, #1 + WORD $0xf9000020 // str x0, [x1] + WORD $0x8b080138 // add x24, x9, x8 + WORD $0x39c00307 // ldrsb w7, [x24] + WORD $0x3400e7e7 // cbz w7, LBB0_387 $7420(%rip) + WORD $0xd100072a // sub x10, x25, #1 + WORD $0x8b0a0c4c // add x12, x2, x10, lsl #3 + WORD $0xb8408d8d // ldr w13, [x12, #8]! + WORD $0xb10006ff // cmn x23, #1 + WORD $0x9a970117 // csel x23, x8, x23, eq + WORD $0x510005ad // sub w13, w13, #1 + WORD $0x710015bf // cmp w13, #5 + WORD $0x54000f48 // b.hi LBB0_53 $488(%rip) + WORD $0x1000008f // adr x15, LBB0_32 $16(%rip) + WORD $0x786d7893 // ldrh w19, [x4, x13, lsl #1] + WORD $0x8b1309ef // add x15, x15, x19, lsl #2 + WORD $0xd61f01e0 // br x15 +LBB0_32: + WORD $0x7100b0ff // cmp w7, #44 + WORD $0x540021e0 // b.eq LBB0_90 $1084(%rip) + WORD $0x710174ff // cmp w7, #93 + WORD $0x54002100 // b.eq LBB0_89 $1056(%rip) + WORD $0x1400073b // b LBB0_394 $7404(%rip) +LBB0_34: + WORD $0x7100b0ff // cmp w7, #44 + WORD $0x54002061 // b.ne LBB0_88 $1036(%rip) + WORD $0xf13fff3f // cmp x25, #4095 + WORD $0x5400e58c // b.gt LBB0_388 $7344(%rip) + WORD $0x91000728 // add x8, x25, #1 + WORD $0xf9000048 // str x8, [x2] + WORD $0x8b190c48 // add x8, x2, x25, lsl #3 + WORD $0x5280006a // mov w10, #3 + WORD $0x17ffff9d // b LBB0_2 $-396(%rip) +LBB0_37: + WORD $0x710088ff // cmp w7, #34 + WORD $0x5400e601 // b.ne LBB0_394 $7360(%rip) + WORD $0x5280008a // mov w10, #4 + WORD $0xf900018a // str x10, [x12] + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0001fa // subs x26, x15, x0 + WORD $0x37282c03 // tbnz w3, #5, LBB0_103 $1408(%rip) + WORD $0x5400f020 // b.eq LBB0_417 $7684(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x5400b8a3 // b.lo LBB0_315 $5908(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_42: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405554 // ldp q20, q21, [x10] + WORD $0xad415d56 // ldp q22, q23, [x10, #32] + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e208efb // cmeq.16b v27, v23, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x6e218ef7 // cmeq.16b v23, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x4e221f38 // and.16b v24, v25, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x4e221f58 // and.16b v24, v26, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x4e221f78 // and.16b v24, v27, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260293 // fmov w19, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26029c // fmov w28, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xd3607e6c // lsl x12, x19, #32 + WORD $0xb3503f8c // bfi x12, x28, #48, #16 + WORD $0x53103ced // lsl w13, w7, #16 + WORD $0xaa0d018c // orr x12, x12, x13 + WORD $0xaa11018c // orr x12, x12, x17 + WORD $0xb500010c // cbnz x12, LBB0_46 $32(%rip) + WORD $0xb50001bb // cbnz x27, LBB0_47 $52(%rip) + WORD $0xb50002ea // cbnz x10, LBB0_48 $92(%rip) +LBB0_45: + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff8a8 // b.hi LBB0_42 $-236(%rip) + WORD $0x140003f7 // b LBB0_238 $4060(%rip) +LBB0_46: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0018d // rbit x13, x12 + WORD $0xdac011ad // clz x13, x13 + WORD $0x8b0001ad // add x13, x13, x0 + WORD $0x9a8d1318 // csel x24, x24, x13, ne + WORD $0x9a8d1339 // csel x25, x25, x13, ne +LBB0_47: + WORD $0x8a3b018d // bic x13, x12, x27 + WORD $0xaa0d076e // orr x14, x27, x13, lsl #1 + WORD $0x8a2e018c // bic x12, x12, x14 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0d018c // adds x12, x12, x13 + WORD $0x1a9f37fb // cset w27, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0e018c // and x12, x12, x14 + WORD $0x8a2c014a // bic x10, x10, x12 + WORD $0xb4fffd6a // cbz x10, LBB0_45 $-84(%rip) +LBB0_48: + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x1400017d // b LBB0_115 $1524(%rip) +LBB0_49: + WORD $0x7100e8ff // cmp w7, #58 + WORD $0x5400da21 // b.ne LBB0_394 $6980(%rip) + WORD $0xf900019f // str xzr, [x12] + WORD $0x17ffff3b // b LBB0_3 $-788(%rip) +LBB0_51: + WORD $0x710174ff // cmp w7, #93 + WORD $0x54001320 // b.eq LBB0_89 $612(%rip) + WORD $0xf900018b // str x11, [x12] + WORD $0x14000002 // b LBB0_54 $8(%rip) +LBB0_53: + WORD $0xf900004a // str x10, [x2] +LBB0_54: + WORD $0x7101ecff // cmp w7, #123 + WORD $0x5400d908 // b.hi LBB0_394 $6944(%rip) + WORD $0x9280000f // mov x15, #-1 +Lloh12: + WORD $0x1000e58d // adr x13, LJTI0_1 $7344(%rip) +Lloh13: + WORD $0x910001ad // add x13, x13, LJTI0_1@PAGEOFF $0(%rip) + WORD $0x1000008a // adr x10, LBB0_56 $16(%rip) + WORD $0x786779ac // ldrh w12, [x13, x7, lsl #1] + WORD $0x8b0c094a // add x10, x10, x12, lsl #2 + WORD $0xd61f0140 // br x10 +LBB0_56: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xeb080153 // subs x19, x10, x8 + WORD $0x5400d740 // b.eq LBB0_391 $6888(%rip) + WORD $0x3940030a // ldrb w10, [x24] + WORD $0x7100c15f // cmp w10, #48 + WORD $0x54000181 // b.ne LBB0_61 $48(%rip) + WORD $0xf100067f // cmp x19, #1 + WORD $0x54003040 // b.eq LBB0_131 $1544(%rip) + WORD $0x3860692a // ldrb w10, [x9, x0] + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x54002fc8 // b.hi LBB0_131 $1528(%rip) + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xb20903ec // mov x12, #36028797027352576 + WORD $0xf280002c // movk x12, #1 + WORD $0xea0c015f // tst x10, x12 + WORD $0x54002f20 // b.eq LBB0_131 $1508(%rip) +LBB0_61: + WORD $0xf100427f // cmp x19, #16 + WORD $0x5400a3a3 // b.lo LBB0_301 $5236(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800019 // mov x25, #-1 + WORD $0x92800000 // mov x0, #-1 + WORD $0x9280000f // mov x15, #-1 + WORD $0xaa1303fa // mov x26, x19 +LBB0_63: + WORD $0x3cfb6b14 // ldr q20, [x24, x27] + WORD $0x6e258e95 // cmeq.16b v21, v20, v5 + WORD $0x6e268e96 // cmeq.16b v22, v20, v6 + WORD $0x6e278e97 // cmeq.16b v23, v20, v7 + WORD $0x4e308698 // add.16b v24, v20, v16 + WORD $0x6e383638 // cmhi.16b v24, v17, v24 + WORD $0x4e321e94 // and.16b v20, v20, v18 + WORD $0x6e338e94 // cmeq.16b v20, v20, v19 + WORD $0x4eb61ef6 // orr.16b v22, v23, v22 + WORD $0x4eb51e97 // orr.16b v23, v20, v21 + WORD $0x4eb61ef7 // orr.16b v23, v23, v22 + WORD $0x4eb81ef7 // orr.16b v23, v23, v24 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x2a2c03ec // mvn w12, w12 + WORD $0x32103d8c // orr w12, w12, #0xffff0000 + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac01187 // clz w7, w12 + WORD $0x1ac722ac // lsl w12, w21, w7 + WORD $0x0a2c0151 // bic w17, w10, w12 + WORD $0x0a2c01bc // bic w28, w13, w12 + WORD $0x0a2c01de // bic w30, w14, w12 + WORD $0x710040ff // cmp w7, #16 + WORD $0x1a91014c // csel w12, w10, w17, eq + WORD $0x1a9c01bc // csel w28, w13, w28, eq + WORD $0x1a9e01ca // csel w10, w14, w30, eq + WORD $0x5100058d // sub w13, w12, #1 + WORD $0x6a0c01ad // ands w13, w13, w12 + WORD $0x54007041 // b.ne LBB0_234 $3592(%rip) + WORD $0x5100078d // sub w13, w28, #1 + WORD $0x6a1c01ad // ands w13, w13, w28 + WORD $0x54006fe1 // b.ne LBB0_234 $3580(%rip) + WORD $0x5100054d // sub w13, w10, #1 + WORD $0x6a0a01ad // ands w13, w13, w10 + WORD $0x54006f81 // b.ne LBB0_234 $3568(%rip) + WORD $0x340000cc // cbz w12, LBB0_69 $24(%rip) + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb10005ff // cmn x15, #1 + WORD $0x54007c21 // b.ne LBB0_252 $3972(%rip) + WORD $0x8b0c036f // add x15, x27, x12 +LBB0_69: + WORD $0x340000dc // cbz w28, LBB0_72 $24(%rip) + WORD $0x5ac0038c // rbit w12, w28 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb100041f // cmn x0, #1 + WORD $0x54007b61 // b.ne LBB0_252 $3948(%rip) + WORD $0x8b0c0360 // add x0, x27, x12 +LBB0_72: + WORD $0x340000ca // cbz w10, LBB0_75 $24(%rip) + WORD $0x5ac0014a // rbit w10, w10 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x54008621 // b.ne LBB0_265 $4292(%rip) + WORD $0x8b0a0379 // add x25, x27, x10 +LBB0_75: + WORD $0x710040ff // cmp w7, #16 + WORD $0x540022c1 // b.ne LBB0_118 $1112(%rip) + WORD $0xd100435a // sub x26, x26, #16 + WORD $0x9100437b // add x27, x27, #16 + WORD $0xf1003f5f // cmp x26, #15 + WORD $0x54fff708 // b.hi LBB0_63 $-288(%rip) + WORD $0x8b1b0307 // add x7, x24, x27 + WORD $0xeb1b027f // cmp x19, x27 + WORD $0x54002220 // b.eq LBB0_119 $1092(%rip) +LBB0_78: + WORD $0x8b1a00ea // add x10, x7, x26 + WORD $0xf9401fec // ldr x12, [sp, #56] + WORD $0x8b08018c // add x12, x12, x8 + WORD $0xcb070193 // sub x19, x12, x7 + WORD $0xcb1800fb // sub x27, x7, x24 + WORD $0xaa0703fc // mov x28, x7 + WORD $0x1400000b // b LBB0_82 $44(%rip) +LBB0_79: + WORD $0x7101959f // cmp w12, #101 + WORD $0x54002101 // b.ne LBB0_119 $1056(%rip) +LBB0_80: + WORD $0xb100041f // cmn x0, #1 + WORD $0xaa1b03e0 // mov x0, x27 + WORD $0x54002301 // b.ne LBB0_129 $1120(%rip) +LBB0_81: + WORD $0xd1000673 // sub x19, x19, #1 + WORD $0x9100077b // add x27, x27, #1 + WORD $0xaa1c03e7 // mov x7, x28 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb40056fa // cbz x26, LBB0_191 $2780(%rip) +LBB0_82: + WORD $0x38c0178c // ldrsb w12, [x28], #1 + WORD $0x5100c18d // sub w13, w12, #48 + WORD $0x710029bf // cmp w13, #10 + WORD $0x54ffff03 // b.lo LBB0_81 $-32(%rip) + WORD $0x5100ad8d // sub w13, w12, #43 + WORD $0x710069bf // cmp w13, #26 + WORD $0x54fffe08 // b.hi LBB0_79 $-64(%rip) + WORD $0x10fffe2c // adr x12, LBB0_80 $-60(%rip) + WORD $0x786d7ace // ldrh w14, [x22, x13, lsl #1] + WORD $0x8b0e098c // add x12, x12, x14, lsl #2 + WORD $0xd61f0180 // br x12 +LBB0_85: + WORD $0xb100073f // cmn x25, #1 + WORD $0xaa1b03f9 // mov x25, x27 + WORD $0x54fffdc0 // b.eq LBB0_81 $-72(%rip) + WORD $0x14000104 // b LBB0_129 $1040(%rip) +LBB0_86: + WORD $0xb10005ff // cmn x15, #1 + WORD $0xaa1b03ef // mov x15, x27 + WORD $0x54fffd40 // b.eq LBB0_81 $-88(%rip) + WORD $0x14000100 // b LBB0_129 $1024(%rip) +LBB0_87: + WORD $0x710088ff // cmp w7, #34 + WORD $0x540001e0 // b.eq LBB0_92 $60(%rip) +LBB0_88: + WORD $0x7101f4ff // cmp w7, #125 + WORD $0x5400c6a1 // b.ne LBB0_394 $6356(%rip) +LBB0_89: + WORD $0xf900004a // str x10, [x2] + WORD $0xaa0a03f9 // mov x25, x10 + WORD $0xaa1703ef // mov x15, x23 + WORD $0xb5ffd40a // cbnz x10, LBB0_4 $-1408(%rip) + WORD $0x1400063e // b LBB0_400 $6392(%rip) +LBB0_90: + WORD $0xf13fff3f // cmp x25, #4095 + WORD $0x5400c46c // b.gt LBB0_388 $6284(%rip) + WORD $0x91000728 // add x8, x25, #1 + WORD $0xf9000048 // str x8, [x2] + WORD $0x8b190c48 // add x8, x2, x25, lsl #3 + WORD $0xf900051f // str xzr, [x8, #8] + WORD $0x17fffe95 // b LBB0_3 $-1452(%rip) +LBB0_92: + WORD $0x5280004a // mov w10, #2 + WORD $0xf900018a // str x10, [x12] + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0001fa // subs x26, x15, x0 + WORD $0x37281e23 // tbnz w3, #5, LBB0_132 $964(%rip) + WORD $0x5400cf40 // b.eq LBB0_417 $6632(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x540099e3 // b.lo LBB0_318 $4924(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_96: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405554 // ldp q20, q21, [x10] + WORD $0xad415d56 // ldp q22, q23, [x10, #32] + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e208efb // cmeq.16b v27, v23, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x6e218ef7 // cmeq.16b v23, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x4e221f38 // and.16b v24, v25, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x4e221f58 // and.16b v24, v26, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x4e221f78 // and.16b v24, v27, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260293 // fmov w19, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26029c // fmov w28, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xd3607e6c // lsl x12, x19, #32 + WORD $0xb3503f8c // bfi x12, x28, #48, #16 + WORD $0x53103ced // lsl w13, w7, #16 + WORD $0xaa0d018c // orr x12, x12, x13 + WORD $0xaa11018c // orr x12, x12, x17 + WORD $0xb500010c // cbnz x12, LBB0_100 $32(%rip) + WORD $0xb50001bb // cbnz x27, LBB0_101 $52(%rip) + WORD $0xb50002ea // cbnz x10, LBB0_102 $92(%rip) +LBB0_99: + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff8a8 // b.hi LBB0_96 $-236(%rip) + WORD $0x14000356 // b LBB0_254 $3416(%rip) +LBB0_100: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0018d // rbit x13, x12 + WORD $0xdac011ad // clz x13, x13 + WORD $0x8b0001ad // add x13, x13, x0 + WORD $0x9a8d1318 // csel x24, x24, x13, ne + WORD $0x9a8d1339 // csel x25, x25, x13, ne +LBB0_101: + WORD $0x8a3b018d // bic x13, x12, x27 + WORD $0xaa0d076e // orr x14, x27, x13, lsl #1 + WORD $0x8a2e018c // bic x12, x12, x14 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0d018c // adds x12, x12, x13 + WORD $0x1a9f37fb // cset w27, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0e018c // and x12, x12, x14 + WORD $0x8a2c014a // bic x10, x10, x12 + WORD $0xb4fffd6a // cbz x10, LBB0_99 $-84(%rip) +LBB0_102: + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x1400010e // b LBB0_144 $1080(%rip) +LBB0_103: + WORD $0x5400c440 // b.eq LBB0_417 $6280(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54008da3 // b.lo LBB0_316 $4532(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x9280001b // mov x27, #-1 +LBB0_106: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260307 // fmov w7, s24 + WORD $0x6e218ef8 // cmeq.16b v24, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0x6e218ed8 // cmeq.16b v24, v22, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031e // fmov w30, s24 + WORD $0x6e218eb8 // cmeq.16b v24, v21, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e218e98 // cmeq.16b v24, v20, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503ced // bfi x13, x7, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0193 // orr x19, x12, x10 + WORD $0xd3607e2a // lsl x10, x17, #32 + WORD $0xb3503dca // bfi x10, x14, #48, #16 + WORD $0x53103fcc // lsl w12, w30, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa1c014a // orr x10, x10, x28 + WORD $0xb500044a // cbnz x10, LBB0_111 $136(%rip) + WORD $0xb50004f9 // cbnz x25, LBB0_112 $156(%rip) +LBB0_108: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000313 // cbnz x19, LBB0_113 $96(%rip) + WORD $0xb500aeca // cbnz x10, LBB0_395 $5592(%rip) + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff568 // b.hi LBB0_106 $-340(%rip) + WORD $0x140002a1 // b LBB0_243 $2692(%rip) +LBB0_111: + WORD $0xb100077f // cmn x27, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c137b // csel x27, x27, x12, ne +LBB0_112: + WORD $0x8a39014c // bic x12, x10, x25 + WORD $0xaa0c072d // orr x13, x25, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a0273 // bic x19, x19, x10 + WORD $0x17ffffd0 // b LBB0_108 $-192(%rip) +LBB0_113: + WORD $0xdac0026c // rbit x12, x19 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x5400b623 // b.lo LBB0_418 $5828(%rip) + WORD $0x8b00018a // add x10, x12, x0 +LBB0_115: + WORD $0x91000540 // add x0, x10, #1 +LBB0_116: + WORD $0xb7f8a980 // tbnz x0, #63, LBB0_389 $5424(%rip) +LBB0_117: + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb27ff7ea // mov x10, #9223372036854775806 + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x54ffb789 // b.ls LBB0_3 $-2320(%rip) + WORD $0x1400055d // b LBB0_400 $5492(%rip) +LBB0_118: + WORD $0x8b27430a // add x10, x24, w7, uxtw + WORD $0x8b1b0147 // add x7, x10, x27 +LBB0_119: + WORD $0x92800013 // mov x19, #-1 + WORD $0xb400a90f // cbz x15, LBB0_392 $5408(%rip) +LBB0_120: + WORD $0xb400a8f9 // cbz x25, LBB0_392 $5404(%rip) + WORD $0xb400a8c0 // cbz x0, LBB0_392 $5400(%rip) + WORD $0xcb1800ea // sub x10, x7, x24 + WORD $0xd100054c // sub x12, x10, #1 + WORD $0xeb0c01ff // cmp x15, x12 + WORD $0x54000160 // b.eq LBB0_128 $44(%rip) + WORD $0xeb0c033f // cmp x25, x12 + WORD $0x54000120 // b.eq LBB0_128 $36(%rip) + WORD $0xeb0c001f // cmp x0, x12 + WORD $0x540000e0 // b.eq LBB0_128 $28(%rip) + WORD $0xf100072c // subs x12, x25, #1 + WORD $0x5400118b // b.lt LBB0_148 $560(%rip) + WORD $0xeb0c001f // cmp x0, x12 + WORD $0x54001140 // b.eq LBB0_148 $552(%rip) + WORD $0xaa3903f3 // mvn x19, x25 + WORD $0x14000002 // b LBB0_129 $8(%rip) +LBB0_128: + WORD $0xcb0a03f3 // neg x19, x10 +LBB0_129: + WORD $0xb7f8a6d3 // tbnz x19, #63, LBB0_392 $5336(%rip) + WORD $0x8b080260 // add x0, x19, x8 +LBB0_131: + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb6ffb428 // tbz x8, #63, LBB0_3 $-2428(%rip) + WORD $0x14000542 // b LBB0_400 $5384(%rip) +LBB0_132: + WORD $0x5400b140 // b.eq LBB0_417 $5672(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54007cc3 // b.lo LBB0_319 $3992(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x9280001b // mov x27, #-1 +LBB0_135: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x6e218ef8 // cmeq.16b v24, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e218ed8 // cmeq.16b v24, v22, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260307 // fmov w7, s24 + WORD $0x6e218eb8 // cmeq.16b v24, v21, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0x6e218e98 // cmeq.16b v24, v20, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031e // fmov w30, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0193 // orr x19, x12, x10 + WORD $0xd3607f8a // lsl x10, x28, #32 + WORD $0xb3503fca // bfi x10, x30, #48, #16 + WORD $0x53103cec // lsl w12, w7, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa11014a // orr x10, x10, x17 + WORD $0xb500044a // cbnz x10, LBB0_140 $136(%rip) + WORD $0xb50004f9 // cbnz x25, LBB0_141 $156(%rip) +LBB0_137: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000313 // cbnz x19, LBB0_142 $96(%rip) + WORD $0xb5009bca // cbnz x10, LBB0_395 $4984(%rip) + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff568 // b.hi LBB0_135 $-340(%rip) + WORD $0x1400026f // b LBB0_259 $2492(%rip) +LBB0_140: + WORD $0xb100077f // cmn x27, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c137b // csel x27, x27, x12, ne +LBB0_141: + WORD $0x8a39014c // bic x12, x10, x25 + WORD $0xaa0c072d // orr x13, x25, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a0273 // bic x19, x19, x10 + WORD $0x17ffffd0 // b LBB0_137 $-192(%rip) +LBB0_142: + WORD $0xdac0026c // rbit x12, x19 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x5400a323 // b.lo LBB0_418 $5220(%rip) + WORD $0x8b00018a // add x10, x12, x0 +LBB0_144: + WORD $0x91000540 // add x0, x10, #1 +LBB0_145: + WORD $0xb7f89680 // tbnz x0, #63, LBB0_389 $4816(%rip) + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb27ff7ea // mov x10, #9223372036854775806 + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x540098c8 // b.hi LBB0_400 $4888(%rip) + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x54ffa38d // b.le LBB0_1 $-2960(%rip) + WORD $0x140004a9 // b LBB0_388 $4772(%rip) +LBB0_148: + WORD $0xaa0001ec // orr x12, x15, x0 + WORD $0xb7f813ac // tbnz x12, #63, LBB0_178 $628(%rip) + WORD $0xeb0001ff // cmp x15, x0 + WORD $0x5400136b // b.lt LBB0_178 $620(%rip) + WORD $0xaa2f03f3 // mvn x19, x15 + WORD $0x17ffff75 // b LBB0_129 $-556(%rip) +LBB0_151: + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0001fa // subs x26, x15, x0 + WORD $0x372813c3 // tbnz w3, #5, LBB0_179 $632(%rip) + WORD $0x5400a020 // b.eq LBB0_417 $5124(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54006d23 // b.lo LBB0_321 $3492(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_155: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405554 // ldp q20, q21, [x10] + WORD $0xad415d56 // ldp q22, q23, [x10, #32] + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e208efb // cmeq.16b v27, v23, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x6e218ef7 // cmeq.16b v23, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x4e221f38 // and.16b v24, v25, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x4e221f58 // and.16b v24, v26, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x4e221f78 // and.16b v24, v27, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260285 // fmov w5, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260293 // fmov w19, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xd3607cec // lsl x12, x7, #32 + WORD $0xb3503e6c // bfi x12, x19, #48, #16 + WORD $0x53103cad // lsl w13, w5, #16 + WORD $0xaa0d018c // orr x12, x12, x13 + WORD $0xaa11018c // orr x12, x12, x17 + WORD $0xb500010c // cbnz x12, LBB0_159 $32(%rip) + WORD $0xb50001bb // cbnz x27, LBB0_160 $52(%rip) + WORD $0xb50002ea // cbnz x10, LBB0_161 $92(%rip) +LBB0_158: + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff8a8 // b.hi LBB0_155 $-236(%rip) + WORD $0x14000280 // b LBB0_290 $2560(%rip) +LBB0_159: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0018d // rbit x13, x12 + WORD $0xdac011ad // clz x13, x13 + WORD $0x8b0001ad // add x13, x13, x0 + WORD $0x9a8d1318 // csel x24, x24, x13, ne + WORD $0x9a8d1339 // csel x25, x25, x13, ne +LBB0_160: + WORD $0x8a3b018d // bic x13, x12, x27 + WORD $0xaa0d076e // orr x14, x27, x13, lsl #1 + WORD $0x8a2e018c // bic x12, x12, x14 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0d018c // adds x12, x12, x13 + WORD $0x1a9f37fb // cset w27, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0e018c // and x12, x12, x14 + WORD $0x8a2c014a // bic x10, x10, x12 + WORD $0xb4fffd6a // cbz x10, LBB0_158 $-84(%rip) +LBB0_161: + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x91000540 // add x0, x10, #1 + WORD $0xb6ffdfc0 // tbz x0, #63, LBB0_117 $-1032(%rip) + WORD $0x14000448 // b LBB0_389 $4384(%rip) +LBB0_162: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xeb00014f // subs x15, x10, x0 + WORD $0x54008ca0 // b.eq LBB0_401 $4500(%rip) + WORD $0x8b000127 // add x7, x9, x0 + WORD $0x394000ea // ldrb w10, [x7] + WORD $0x7100c15f // cmp w10, #48 + WORD $0x54001861 // b.ne LBB0_194 $780(%rip) + WORD $0xf10005ff // cmp x15, #1 + WORD $0x540016e1 // b.ne LBB0_192 $732(%rip) +LBB0_165: + WORD $0x5280003b // mov w27, #1 + WORD $0x140001b2 // b LBB0_251 $1736(%rip) +LBB0_166: + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x5400870c // b.gt LBB0_388 $4320(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x528000aa // mov w10, #5 + WORD $0x17fffca9 // b LBB0_2 $-3420(%rip) +LBB0_168: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xd100114c // sub x12, x10, #4 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x54008802 // b.hs LBB0_397 $4352(%rip) + WORD $0xb860692a // ldr w10, [x9, x0] + WORD $0x528d8c2c // mov w12, #27745 + WORD $0x72acae6c // movk w12, #25971, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x540089e1 // b.ne LBB0_403 $4412(%rip) + WORD $0x91001500 // add x0, x8, #5 + WORD $0x17fffedf // b LBB0_117 $-1156(%rip) +LBB0_171: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xd1000d4c // sub x12, x10, #3 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x540086a2 // b.hs LBB0_397 $4308(%rip) + WORD $0xb940030a // ldr w10, [x24] + WORD $0x528eadcc // mov w12, #30062 + WORD $0x72ad8d8c // movk w12, #27756, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x54000160 // b.eq LBB0_175 $44(%rip) + WORD $0x14000457 // b LBB0_408 $4444(%rip) +LBB0_173: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xd1000d4c // sub x12, x10, #3 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x54008562 // b.hs LBB0_397 $4268(%rip) + WORD $0xb940030a // ldr w10, [x24] + WORD $0x528e4e8c // mov w12, #29300 + WORD $0x72acaeac // movk w12, #25973, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x54008c41 // b.ne LBB0_412 $4488(%rip) +LBB0_175: + WORD $0x91001100 // add x0, x8, #4 + WORD $0x17fffeca // b LBB0_117 $-1240(%rip) +LBB0_176: + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x5400820c // b.gt LBB0_388 $4160(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x528000ca // mov w10, #6 + WORD $0x17fffc81 // b LBB0_2 $-3580(%rip) +LBB0_178: + WORD $0xd37ffd8c // lsr x12, x12, #63 + WORD $0x5200018c // eor w12, w12, #0x1 + WORD $0xd100040d // sub x13, x0, #1 + WORD $0xeb0d01ff // cmp x15, x13 + WORD $0x1a9f17ed // cset w13, eq + WORD $0x6a0d019f // tst w12, w13 + WORD $0xda800153 // csinv x19, x10, x0, eq + WORD $0x17fffed5 // b LBB0_129 $-1196(%rip) +LBB0_179: + WORD $0x54008c80 // b.eq LBB0_417 $4496(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54005a63 // b.lo LBB0_322 $2892(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x9280001b // mov x27, #-1 +LBB0_182: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x6e218ef8 // cmeq.16b v24, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e218ed8 // cmeq.16b v24, v22, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260305 // fmov w5, s24 + WORD $0x6e218eb8 // cmeq.16b v24, v21, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260307 // fmov w7, s24 + WORD $0x6e218e98 // cmeq.16b v24, v20, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0193 // orr x19, x12, x10 + WORD $0xd3607cea // lsl x10, x7, #32 + WORD $0xb3503f8a // bfi x10, x28, #48, #16 + WORD $0x53103cac // lsl w12, w5, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa11014a // orr x10, x10, x17 + WORD $0xb500044a // cbnz x10, LBB0_187 $136(%rip) + WORD $0xb50004f9 // cbnz x25, LBB0_188 $156(%rip) +LBB0_184: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000313 // cbnz x19, LBB0_189 $96(%rip) + WORD $0xb500770a // cbnz x10, LBB0_395 $3808(%rip) + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff568 // b.hi LBB0_182 $-340(%rip) + WORD $0x140001ed // b LBB0_295 $1972(%rip) +LBB0_187: + WORD $0xb100077f // cmn x27, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c137b // csel x27, x27, x12, ne +LBB0_188: + WORD $0x8a39014c // bic x12, x10, x25 + WORD $0xaa0c072d // orr x13, x25, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a0273 // bic x19, x19, x10 + WORD $0x17ffffd0 // b LBB0_184 $-192(%rip) +LBB0_189: + WORD $0xdac0026c // rbit x12, x19 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54007e63 // b.lo LBB0_418 $4044(%rip) + WORD $0x8b00018a // add x10, x12, x0 + WORD $0x91000540 // add x0, x10, #1 + WORD $0xb6ffc860 // tbz x0, #63, LBB0_117 $-1780(%rip) + WORD $0x1400038d // b LBB0_389 $3636(%rip) +LBB0_191: + WORD $0xaa0a03e7 // mov x7, x10 + WORD $0x92800013 // mov x19, #-1 + WORD $0xb5ffc92f // cbnz x15, LBB0_120 $-1756(%rip) + WORD $0x1400038f // b LBB0_392 $3644(%rip) +LBB0_192: + WORD $0x394004ea // ldrb w10, [x7, #1] + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x54ffe8e8 // b.hi LBB0_165 $-740(%rip) + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0x5280003b // mov w27, #1 + WORD $0xb20903ec // mov x12, #36028797027352576 + WORD $0xf280002c // movk x12, #1 + WORD $0xea0c015f // tst x10, x12 + WORD $0x54001e80 // b.eq LBB0_251 $976(%rip) +LBB0_194: + WORD $0xf10041ff // cmp x15, #16 + WORD $0x54004823 // b.lo LBB0_320 $2308(%rip) + WORD $0xd280001c // mov x28, #0 + WORD $0x9280001a // mov x26, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0x92800018 // mov x24, #-1 + WORD $0xaa0f03fb // mov x27, x15 +LBB0_196: + WORD $0x3cfc68f4 // ldr q20, [x7, x28] + WORD $0x6e258e95 // cmeq.16b v21, v20, v5 + WORD $0x6e268e96 // cmeq.16b v22, v20, v6 + WORD $0x6e278e97 // cmeq.16b v23, v20, v7 + WORD $0x4e308698 // add.16b v24, v20, v16 + WORD $0x6e383638 // cmhi.16b v24, v17, v24 + WORD $0x4e321e94 // and.16b v20, v20, v18 + WORD $0x6e338e94 // cmeq.16b v20, v20, v19 + WORD $0x4eb61ef6 // orr.16b v22, v23, v22 + WORD $0x4eb51e97 // orr.16b v23, v20, v21 + WORD $0x4eb61ef7 // orr.16b v23, v23, v22 + WORD $0x4eb81ef7 // orr.16b v23, v23, v24 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x2a2d03ed // mvn w13, w13 + WORD $0x32103dad // orr w13, w13, #0xffff0000 + WORD $0x5ac001ad // rbit w13, w13 + WORD $0x5ac011b3 // clz w19, w13 + WORD $0x1ad322ad // lsl w13, w21, w19 + WORD $0x0a2d0151 // bic w17, w10, w13 + WORD $0x0a2d019e // bic w30, w12, w13 + WORD $0x0a2d01c5 // bic w5, w14, w13 + WORD $0x7100427f // cmp w19, #16 + WORD $0x1a91014d // csel w13, w10, w17, eq + WORD $0x1a9e018c // csel w12, w12, w30, eq + WORD $0x1a8501ca // csel w10, w14, w5, eq + WORD $0x510005ae // sub w14, w13, #1 + WORD $0x6a0d01de // ands w30, w14, w13 + WORD $0x54002c81 // b.ne LBB0_287 $1424(%rip) + WORD $0x5100058e // sub w14, w12, #1 + WORD $0x6a0c01de // ands w30, w14, w12 + WORD $0x54002c21 // b.ne LBB0_287 $1412(%rip) + WORD $0x5100054e // sub w14, w10, #1 + WORD $0x6a0a01de // ands w30, w14, w10 + WORD $0x54002bc1 // b.ne LBB0_287 $1400(%rip) + WORD $0x340000cd // cbz w13, LBB0_202 $24(%rip) + WORD $0x5ac001ad // rbit w13, w13 + WORD $0x5ac011ad // clz w13, w13 + WORD $0xb100071f // cmn x24, #1 + WORD $0x54003801 // b.ne LBB0_302 $1792(%rip) + WORD $0x8b0d0398 // add x24, x28, x13 +LBB0_202: + WORD $0x340000cc // cbz w12, LBB0_205 $24(%rip) + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb100073f // cmn x25, #1 + WORD $0x540037a1 // b.ne LBB0_303 $1780(%rip) + WORD $0x8b0c0399 // add x25, x28, x12 +LBB0_205: + WORD $0x340000ca // cbz w10, LBB0_208 $24(%rip) + WORD $0x5ac0014a // rbit w10, w10 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb100075f // cmn x26, #1 + WORD $0x54003741 // b.ne LBB0_304 $1768(%rip) + WORD $0x8b0a039a // add x26, x28, x10 +LBB0_208: + WORD $0x7100427f // cmp w19, #16 + WORD $0x54000541 // b.ne LBB0_223 $168(%rip) + WORD $0xd100437b // sub x27, x27, #16 + WORD $0x9100439c // add x28, x28, #16 + WORD $0xf1003f7f // cmp x27, #15 + WORD $0x54fff708 // b.hi LBB0_196 $-288(%rip) + WORD $0x8b1c00f3 // add x19, x7, x28 + WORD $0xeb1c01ff // cmp x15, x28 + WORD $0x540004a0 // b.eq LBB0_224 $148(%rip) +LBB0_211: + WORD $0x8b1b026e // add x14, x19, x27 + WORD $0xf9401bea // ldr x10, [sp, #48] + WORD $0x8b13014a // add x10, x10, x19 + WORD $0xcb08015c // sub x28, x10, x8 + WORD $0xaa1303ef // mov x15, x19 + WORD $0x14000008 // b LBB0_215 $32(%rip) +LBB0_212: + WORD $0xb100075f // cmn x26, #1 + WORD $0x54002861 // b.ne LBB0_289 $1292(%rip) + WORD $0xd100079a // sub x26, x28, #1 +LBB0_214: + WORD $0x9100079c // add x28, x28, #1 + WORD $0xaa0f03f3 // mov x19, x15 + WORD $0xd100077b // sub x27, x27, #1 + WORD $0xb400133b // cbz x27, LBB0_253 $612(%rip) +LBB0_215: + WORD $0x38c015ea // ldrsb w10, [x15], #1 + WORD $0x5100c14c // sub w12, w10, #48 + WORD $0x7100299f // cmp w12, #10 + WORD $0x54ffff23 // b.lo LBB0_214 $-28(%rip) + WORD $0x5100ad4c // sub w12, w10, #43 + WORD $0x7100699f // cmp w12, #26 + WORD $0x54000128 // b.hi LBB0_220 $36(%rip) + WORD $0x10fffe4a // adr x10, LBB0_212 $-56(%rip) + WORD $0x386c6a8d // ldrb w13, [x20, x12] + WORD $0x8b0d094a // add x10, x10, x13, lsl #2 + WORD $0xd61f0140 // br x10 +LBB0_218: + WORD $0xb100071f // cmn x24, #1 + WORD $0x54002621 // b.ne LBB0_289 $1220(%rip) + WORD $0xd1000798 // sub x24, x28, #1 + WORD $0x17ffffee // b LBB0_214 $-72(%rip) +LBB0_220: + WORD $0x7101955f // cmp w10, #101 + WORD $0x540000e1 // b.ne LBB0_224 $28(%rip) +LBB0_221: + WORD $0xb100073f // cmn x25, #1 + WORD $0x54002561 // b.ne LBB0_289 $1196(%rip) + WORD $0xd1000799 // sub x25, x28, #1 + WORD $0x17ffffe8 // b LBB0_214 $-96(%rip) +LBB0_223: + WORD $0x8b3340ea // add x10, x7, w19, uxtw + WORD $0x8b1c0153 // add x19, x10, x28 +LBB0_224: + WORD $0x9280001b // mov x27, #-1 + WORD $0xb40064f8 // cbz x24, LBB0_402 $3228(%rip) +LBB0_225: + WORD $0xb40064da // cbz x26, LBB0_402 $3224(%rip) + WORD $0xb40064b9 // cbz x25, LBB0_402 $3220(%rip) + WORD $0xcb07026a // sub x10, x19, x7 + WORD $0xd100054c // sub x12, x10, #1 + WORD $0xeb0c031f // cmp x24, x12 + WORD $0x54000160 // b.eq LBB0_233 $44(%rip) + WORD $0xeb0c035f // cmp x26, x12 + WORD $0x54000120 // b.eq LBB0_233 $36(%rip) + WORD $0xeb0c033f // cmp x25, x12 + WORD $0x540000e0 // b.eq LBB0_233 $28(%rip) + WORD $0xf100074c // subs x12, x26, #1 + WORD $0x5400018b // b.lt LBB0_235 $48(%rip) + WORD $0xeb0c033f // cmp x25, x12 + WORD $0x54000140 // b.eq LBB0_235 $40(%rip) + WORD $0xaa3a03fb // mvn x27, x26 + WORD $0x1400006a // b LBB0_250 $424(%rip) +LBB0_233: + WORD $0xcb0a03fb // neg x27, x10 + WORD $0x14000068 // b LBB0_250 $416(%rip) +LBB0_234: + WORD $0x5ac001aa // rbit w10, w13 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3b03ec // mvn x12, x27 + WORD $0xcb0a0193 // sub x19, x12, x10 + WORD $0x17fffdbf // b LBB0_129 $-2308(%rip) +LBB0_235: + WORD $0xaa19030c // orr x12, x24, x25 + WORD $0xb7f80b4c // tbnz x12, #63, LBB0_249 $360(%rip) + WORD $0xeb19031f // cmp x24, x25 + WORD $0x54000b0b // b.lt LBB0_249 $352(%rip) + WORD $0xaa3803fb // mvn x27, x24 + WORD $0x1400005d // b LBB0_250 $372(%rip) +LBB0_238: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54003a63 // b.lo LBB0_326 $1868(%rip) +LBB0_239: + WORD $0xad405414 // ldp q20, q21, [x0] + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e208eb7 // cmeq.16b v23, v21, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c7 // fmov w7, s22 + WORD $0x4e221ef6 // and.16b v22, v23, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x33103d87 // bfi w7, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350034aa // cbnz w10, LBB0_323 $1684(%rip) + WORD $0xb500357b // cbnz x27, LBB0_324 $1708(%rip) + WORD $0xb40036e7 // cbz x7, LBB0_325 $1756(%rip) +LBB0_242: + WORD $0xdac000ea // rbit x10, x7 + WORD $0xdac0114a // clz x10, x10 + WORD $0xf94017ec // ldr x12, [sp, #40] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a0180 // add x0, x12, x10 + WORD $0x17fffd7a // b LBB0_116 $-2584(%rip) +LBB0_243: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54001383 // b.lo LBB0_268 $624(%rip) +LBB0_244: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602da // fmov w26, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e218eb6 // cmeq.16b v22, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e218e96 // cmeq.16b v22, v20, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cd // fmov w13, s22 + WORD $0x33103d9a // bfi w26, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350037aa // cbnz w10, LBB0_338 $1780(%rip) + WORD $0xb5003859 // cbnz x25, LBB0_339 $1800(%rip) +LBB0_246: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb4000e5a // cbz x26, LBB0_266 $456(%rip) + WORD $0xdac0034c // rbit x12, x26 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54005fa3 // b.lo LBB0_419 $3060(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0x17fffd48 // b LBB0_116 $-2784(%rip) +LBB0_249: + WORD $0xd37ffd8c // lsr x12, x12, #63 + WORD $0x5200018c // eor w12, w12, #0x1 + WORD $0xd100072d // sub x13, x25, #1 + WORD $0xeb0d031f // cmp x24, x13 + WORD $0x1a9f17ed // cset w13, eq + WORD $0x6a0d019f // tst w12, w13 + WORD $0xda99015b // csinv x27, x10, x25, eq +LBB0_250: + WORD $0xb7f855bb // tbnz x27, #63, LBB0_402 $2740(%rip) +LBB0_251: + WORD $0x8b000360 // add x0, x27, x0 + WORD $0x17fffd3f // b LBB0_117 $-2820(%rip) +LBB0_252: + WORD $0xaa3b03ea // mvn x10, x27 + WORD $0xcb2c4153 // sub x19, x10, w12, uxtw + WORD $0x17fffd57 // b LBB0_129 $-2724(%rip) +LBB0_253: + WORD $0xaa0e03f3 // mov x19, x14 + WORD $0x9280001b // mov x27, #-1 + WORD $0xb5ffeff8 // cbnz x24, LBB0_225 $-516(%rip) + WORD $0x140002a4 // b LBB0_402 $2704(%rip) +LBB0_254: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54003763 // b.lo LBB0_343 $1772(%rip) +LBB0_255: + WORD $0xad405414 // ldp q20, q21, [x0] + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e208eb7 // cmeq.16b v23, v21, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c7 // fmov w7, s22 + WORD $0x4e221ef6 // and.16b v22, v23, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x33103d87 // bfi w7, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350031aa // cbnz w10, LBB0_340 $1588(%rip) + WORD $0xb500327b // cbnz x27, LBB0_341 $1612(%rip) + WORD $0xb40033e7 // cbz x7, LBB0_342 $1660(%rip) +LBB0_258: + WORD $0xdac000ea // rbit x10, x7 + WORD $0xdac0114a // clz x10, x10 + WORD $0xf94017ec // ldr x12, [sp, #40] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a0180 // add x0, x12, x10 + WORD $0x17fffdac // b LBB0_145 $-2384(%rip) +LBB0_259: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54000b03 // b.lo LBB0_279 $352(%rip) +LBB0_260: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602da // fmov w26, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e218eb6 // cmeq.16b v22, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e218e96 // cmeq.16b v22, v20, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cd // fmov w13, s22 + WORD $0x33103d9a // bfi w26, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350034aa // cbnz w10, LBB0_355 $1684(%rip) + WORD $0xb5003559 // cbnz x25, LBB0_356 $1704(%rip) +LBB0_262: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb40005da // cbz x26, LBB0_277 $184(%rip) + WORD $0xdac0034c // rbit x12, x26 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x540052e3 // b.lo LBB0_419 $2652(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0x17fffd7a // b LBB0_145 $-2584(%rip) +LBB0_265: + WORD $0xaa3b03ec // mvn x12, x27 + WORD $0xcb2a4193 // sub x19, x12, w10, uxtw + WORD $0x17fffcfb // b LBB0_129 $-3092(%rip) +LBB0_266: + WORD $0x350051ec // cbnz w12, LBB0_419 $2620(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_268: + WORD $0xb5003499 // cbnz x25, LBB0_359 $1680(%rip) + WORD $0xb400451a // cbz x26, LBB0_390 $2208(%rip) +LBB0_270: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x54000300 // b.eq LBB0_276 $96(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_274 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54005109 // b.ls LBB0_420 $2592(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffea1 // b.ne LBB0_270 $-44(%rip) + WORD $0x1400021b // b LBB0_390 $2156(%rip) +LBB0_274: + WORD $0xf100075f // cmp x26, #1 + WORD $0x54004320 // b.eq LBB0_390 $2148(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8a1318 // csel x24, x24, x10, ne + WORD $0x5280004a // mov w10, #2 + WORD $0x9a8a114c // csel x12, x10, x10, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffd01 // b.ne LBB0_270 $-96(%rip) + WORD $0x1400020e // b LBB0_390 $2104(%rip) +LBB0_276: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0x17fffcbd // b LBB0_116 $-3340(%rip) +LBB0_277: + WORD $0x35004dac // cbnz w12, LBB0_419 $2484(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_279: + WORD $0xb50032b9 // cbnz x25, LBB0_363 $1620(%rip) + WORD $0xb40040da // cbz x26, LBB0_390 $2072(%rip) +LBB0_281: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x540003a0 // b.eq LBB0_288 $116(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_285 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54004cc9 // b.ls LBB0_420 $2456(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffea1 // b.ne LBB0_281 $-44(%rip) + WORD $0x140001f9 // b LBB0_390 $2020(%rip) +LBB0_285: + WORD $0xf100075f // cmp x26, #1 + WORD $0x54003ee0 // b.eq LBB0_390 $2012(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8a1318 // csel x24, x24, x10, ne + WORD $0x5280004a // mov w10, #2 + WORD $0x9a8a114c // csel x12, x10, x10, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffd01 // b.ne LBB0_281 $-96(%rip) + WORD $0x140001ec // b LBB0_390 $1968(%rip) +LBB0_287: + WORD $0x5ac003ca // rbit w10, w30 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3c03ec // mvn x12, x28 + WORD $0xcb0a019b // sub x27, x12, x10 + WORD $0x17ffff59 // b LBB0_250 $-668(%rip) +LBB0_288: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0x17fffd2e // b LBB0_145 $-2888(%rip) +LBB0_289: + WORD $0xcb1c03fb // neg x27, x28 + WORD $0x17ffff54 // b LBB0_250 $-688(%rip) +LBB0_290: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54003183 // b.lo LBB0_368 $1584(%rip) +LBB0_291: + WORD $0xad405414 // ldp q20, q21, [x0] + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e208eb7 // cmeq.16b v23, v21, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c7 // fmov w7, s22 + WORD $0x4e221ef6 // and.16b v22, v23, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x33103d87 // bfi w7, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x35002bca // cbnz w10, LBB0_365 $1400(%rip) + WORD $0xb5002c9b // cbnz x27, LBB0_366 $1424(%rip) + WORD $0xb4002e07 // cbz x7, LBB0_367 $1472(%rip) +LBB0_294: + WORD $0xdac000ea // rbit x10, x7 + WORD $0xdac0114a // clz x10, x10 + WORD $0xf94017ec // ldr x12, [sp, #40] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a0180 // add x0, x12, x10 + WORD $0xb6ff8e40 // tbz x0, #63, LBB0_117 $-3640(%rip) + WORD $0x140001bc // b LBB0_389 $1776(%rip) +LBB0_295: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54000863 // b.lo LBB0_307 $268(%rip) +LBB0_296: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602da // fmov w26, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e218eb6 // cmeq.16b v22, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e218e96 // cmeq.16b v22, v20, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cd // fmov w13, s22 + WORD $0x33103d9a // bfi w26, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x35002eca // cbnz w10, LBB0_380 $1496(%rip) + WORD $0xb5002f79 // cbnz x25, LBB0_381 $1516(%rip) +LBB0_298: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb400033a // cbz x26, LBB0_305 $100(%rip) + WORD $0xdac0034c // rbit x12, x26 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54003e63 // b.lo LBB0_419 $1996(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0xb6ff87e0 // tbz x0, #63, LBB0_117 $-3844(%rip) + WORD $0x14000189 // b LBB0_389 $1572(%rip) +LBB0_301: + WORD $0x9280000f // mov x15, #-1 + WORD $0xaa1803e7 // mov x7, x24 + WORD $0xaa1303fa // mov x26, x19 + WORD $0x92800000 // mov x0, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0x17fffb30 // b LBB0_78 $-4928(%rip) +LBB0_302: + WORD $0xaa3c03ea // mvn x10, x28 + WORD $0xcb2d415b // sub x27, x10, w13, uxtw + WORD $0x17fffef4 // b LBB0_250 $-1072(%rip) +LBB0_303: + WORD $0xaa3c03ea // mvn x10, x28 + WORD $0xcb2c415b // sub x27, x10, w12, uxtw + WORD $0x17fffef1 // b LBB0_250 $-1084(%rip) +LBB0_304: + WORD $0xaa3c03ec // mvn x12, x28 + WORD $0xcb2a419b // sub x27, x12, w10, uxtw + WORD $0x17fffeee // b LBB0_250 $-1096(%rip) +LBB0_305: + WORD $0x35003bcc // cbnz w12, LBB0_419 $1912(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_307: + WORD $0xb5002bd9 // cbnz x25, LBB0_382 $1400(%rip) + WORD $0xb4002efa // cbz x26, LBB0_390 $1500(%rip) +LBB0_309: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x540004a0 // b.eq LBB0_317 $148(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_313 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54003ae9 // b.ls LBB0_420 $1884(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffea1 // b.ne LBB0_309 $-44(%rip) + WORD $0x1400016a // b LBB0_390 $1448(%rip) +LBB0_313: + WORD $0xf100075f // cmp x26, #1 + WORD $0x54002d00 // b.eq LBB0_390 $1440(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8a1318 // csel x24, x24, x10, ne + WORD $0x5280004a // mov w10, #2 + WORD $0x9a8a114c // csel x12, x10, x10, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffd01 // b.ne LBB0_309 $-96(%rip) + WORD $0x1400015d // b LBB0_390 $1396(%rip) +LBB0_315: + WORD $0xd280001b // mov x27, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffce02 // b.hs LBB0_239 $-1600(%rip) + WORD $0x14000041 // b LBB0_326 $260(%rip) +LBB0_316: + WORD $0xd2800019 // mov x25, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffd1a2 // b.hs LBB0_244 $-1484(%rip) + WORD $0x17ffff27 // b LBB0_268 $-868(%rip) +LBB0_317: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0xb6ff8000 // tbz x0, #63, LBB0_117 $-4096(%rip) + WORD $0x1400014a // b LBB0_389 $1320(%rip) +LBB0_318: + WORD $0xd280001b // mov x27, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffd8a2 // b.hs LBB0_255 $-1260(%rip) + WORD $0x1400007e // b LBB0_343 $504(%rip) +LBB0_319: + WORD $0xd2800019 // mov x25, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffdc42 // b.hs LBB0_260 $-1144(%rip) + WORD $0x17ffff38 // b LBB0_279 $-800(%rip) +LBB0_320: + WORD $0x92800018 // mov x24, #-1 + WORD $0xaa0703f3 // mov x19, x7 + WORD $0xaa0f03fb // mov x27, x15 + WORD $0x92800019 // mov x25, #-1 + WORD $0x9280001a // mov x26, #-1 + WORD $0x17fffe0c // b LBB0_211 $-2000(%rip) +LBB0_321: + WORD $0xd280001b // mov x27, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffeaa2 // b.hs LBB0_291 $-684(%rip) + WORD $0x140000df // b LBB0_368 $892(%rip) +LBB0_322: + WORD $0xd2800019 // mov x25, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffee62 // b.hs LBB0_296 $-564(%rip) + WORD $0x17ffffb4 // b LBB0_307 $-304(%rip) +LBB0_323: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0d018c // add x12, x12, x13 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_324: + WORD $0x0a3b014c // bic w12, w10, w27 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f799b // bfi w27, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a1b014a // and w10, w10, w27 + WORD $0x1a9f37fb // cset w27, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a070147 // and x7, x10, x7 + WORD $0xb5ffc967 // cbnz x7, LBB0_242 $-1748(%rip) +LBB0_325: + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_326: + WORD $0xb50010db // cbnz x27, LBB0_357 $536(%rip) + WORD $0xb40003da // cbz x26, LBB0_335 $120(%rip) +LBB0_328: + WORD $0xd280000a // mov x10, #0 +LBB0_329: + WORD $0x386a680c // ldrb w12, [x0, x10] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_334 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_332 $20(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xeb0a035f // cmp x26, x10 + WORD $0x54ffff21 // b.ne LBB0_329 $-28(%rip) + WORD $0x14000016 // b LBB0_336 $88(%rip) +LBB0_332: + WORD $0xd100074c // sub x12, x26, #1 + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x540020e0 // b.eq LBB0_390 $1052(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a018c // add x12, x12, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980198 // csel x24, x12, x24, eq + WORD $0x9a990199 // csel x25, x12, x25, eq + WORD $0x8b0a000c // add x12, x0, x10 + WORD $0x91000980 // add x0, x12, #2 + WORD $0xcb0a034c // sub x12, x26, x10 + WORD $0xd1000b4d // sub x13, x26, #2 + WORD $0xd100099a // sub x26, x12, #2 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54fffce1 // b.ne LBB0_328 $-100(%rip) + WORD $0x140000f9 // b LBB0_390 $996(%rip) +LBB0_334: + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0x91000540 // add x0, x10, #1 +LBB0_335: + WORD $0xcb090000 // sub x0, x0, x9 + WORD $0x17fffba7 // b LBB0_116 $-4452(%rip) +LBB0_336: + WORD $0x7100899f // cmp w12, #34 + WORD $0x54001e61 // b.ne LBB0_390 $972(%rip) + WORD $0x8b1a0000 // add x0, x0, x26 + WORD $0x17fffffb // b LBB0_335 $-20(%rip) +LBB0_338: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne +LBB0_339: + WORD $0x0a39014c // bic w12, w10, w25 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f7999 // bfi w25, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a19014a // and w10, w10, w25 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a1a015a // and x26, x10, x26 + WORD $0x17fffe33 // b LBB0_246 $-1844(%rip) +LBB0_340: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0d018c // add x12, x12, x13 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_341: + WORD $0x0a3b014c // bic w12, w10, w27 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f799b // bfi w27, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a1b014a // and w10, w10, w27 + WORD $0x1a9f37fb // cset w27, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a070147 // and x7, x10, x7 + WORD $0xb5ffcc67 // cbnz x7, LBB0_258 $-1652(%rip) +LBB0_342: + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_343: + WORD $0xb500097b // cbnz x27, LBB0_361 $300(%rip) + WORD $0xb40003da // cbz x26, LBB0_352 $120(%rip) +LBB0_345: + WORD $0xd280000a // mov x10, #0 +LBB0_346: + WORD $0x386a680c // ldrb w12, [x0, x10] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_351 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_349 $20(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xeb0a035f // cmp x26, x10 + WORD $0x54ffff21 // b.ne LBB0_346 $-28(%rip) + WORD $0x14000016 // b LBB0_353 $88(%rip) +LBB0_349: + WORD $0xd100074c // sub x12, x26, #1 + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x54001720 // b.eq LBB0_390 $740(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a018c // add x12, x12, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980198 // csel x24, x12, x24, eq + WORD $0x9a990199 // csel x25, x12, x25, eq + WORD $0x8b0a000c // add x12, x0, x10 + WORD $0x91000980 // add x0, x12, #2 + WORD $0xcb0a034c // sub x12, x26, x10 + WORD $0xd1000b4d // sub x13, x26, #2 + WORD $0xd100099a // sub x26, x12, #2 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54fffce1 // b.ne LBB0_345 $-100(%rip) + WORD $0x140000ab // b LBB0_390 $684(%rip) +LBB0_351: + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0x91000540 // add x0, x10, #1 +LBB0_352: + WORD $0xcb090000 // sub x0, x0, x9 + WORD $0x17fffbf1 // b LBB0_145 $-4156(%rip) +LBB0_353: + WORD $0x7100899f // cmp w12, #34 + WORD $0x540014a1 // b.ne LBB0_390 $660(%rip) + WORD $0x8b1a0000 // add x0, x0, x26 + WORD $0x17fffffb // b LBB0_352 $-20(%rip) +LBB0_355: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne +LBB0_356: + WORD $0x0a39014c // bic w12, w10, w25 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f7999 // bfi w25, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a19014a // and w10, w10, w25 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a1a015a // and x26, x10, x26 + WORD $0x17fffe4b // b LBB0_262 $-1748(%rip) +LBB0_357: + WORD $0xb40011fa // cbz x26, LBB0_390 $572(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x9a990159 // csel x25, x10, x25, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffee9a // cbnz x26, LBB0_328 $-560(%rip) + WORD $0x17ffff90 // b LBB0_335 $-448(%rip) +LBB0_359: + WORD $0xb40010ba // cbz x26, LBB0_390 $532(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffcafa // cbnz x26, LBB0_270 $-1700(%rip) + WORD $0x1400007d // b LBB0_390 $500(%rip) +LBB0_361: + WORD $0xb4000f9a // cbz x26, LBB0_390 $496(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x9a990159 // csel x25, x10, x25, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5fff5fa // cbnz x26, LBB0_345 $-324(%rip) + WORD $0x17ffffcb // b LBB0_352 $-212(%rip) +LBB0_363: + WORD $0xb4000e5a // cbz x26, LBB0_390 $456(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffccda // cbnz x26, LBB0_281 $-1640(%rip) + WORD $0x1400006a // b LBB0_390 $424(%rip) +LBB0_365: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0d018c // add x12, x12, x13 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_366: + WORD $0x0a3b014c // bic w12, w10, w27 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f799b // bfi w27, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a1b014a // and w10, w10, w27 + WORD $0x1a9f37fb // cset w27, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a070147 // and x7, x10, x7 + WORD $0xb5ffd247 // cbnz x7, LBB0_294 $-1464(%rip) +LBB0_367: + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_368: + WORD $0xb500085b // cbnz x27, LBB0_384 $264(%rip) + WORD $0xb40003da // cbz x26, LBB0_377 $120(%rip) +LBB0_370: + WORD $0xd280000a // mov x10, #0 +LBB0_371: + WORD $0x386a680c // ldrb w12, [x0, x10] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_376 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_374 $20(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xeb0a035f // cmp x26, x10 + WORD $0x54ffff21 // b.ne LBB0_371 $-28(%rip) + WORD $0x14000017 // b LBB0_378 $92(%rip) +LBB0_374: + WORD $0xd100074c // sub x12, x26, #1 + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x540008a0 // b.eq LBB0_390 $276(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a018c // add x12, x12, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980198 // csel x24, x12, x24, eq + WORD $0x9a990199 // csel x25, x12, x25, eq + WORD $0x8b0a000c // add x12, x0, x10 + WORD $0x91000980 // add x0, x12, #2 + WORD $0xcb0a034c // sub x12, x26, x10 + WORD $0xd1000b4d // sub x13, x26, #2 + WORD $0xd100099a // sub x26, x12, #2 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54fffce1 // b.ne LBB0_370 $-100(%rip) + WORD $0x14000037 // b LBB0_390 $220(%rip) +LBB0_376: + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0x91000540 // add x0, x10, #1 +LBB0_377: + WORD $0xcb090000 // sub x0, x0, x9 + WORD $0xb6ff5cc0 // tbz x0, #63, LBB0_117 $-5224(%rip) + WORD $0x14000030 // b LBB0_389 $192(%rip) +LBB0_378: + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000601 // b.ne LBB0_390 $192(%rip) + WORD $0x8b1a0000 // add x0, x0, x26 + WORD $0x17fffffa // b LBB0_377 $-24(%rip) +LBB0_380: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne +LBB0_381: + WORD $0x0a39014c // bic w12, w10, w25 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f7999 // bfi w25, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a19014a // and w10, w10, w25 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a1a015a // and x26, x10, x26 + WORD $0x17fffe7a // b LBB0_298 $-1560(%rip) +LBB0_382: + WORD $0xb400035a // cbz x26, LBB0_390 $104(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffd3ba // cbnz x26, LBB0_309 $-1420(%rip) + WORD $0x14000012 // b LBB0_390 $72(%rip) +LBB0_384: + WORD $0xb400023a // cbz x26, LBB0_390 $68(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x9a990159 // csel x25, x10, x25, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5fff71a // cbnz x26, LBB0_370 $-288(%rip) + WORD $0x17ffffd4 // b LBB0_377 $-176(%rip) +LBB0_386: + WORD $0xf9000028 // str x8, [x1] +LBB0_387: + WORD $0x9280000f // mov x15, #-1 + WORD $0x1400001a // b LBB0_400 $104(%rip) +LBB0_388: + WORD $0x928000cf // mov x15, #-7 + WORD $0x14000018 // b LBB0_400 $96(%rip) +LBB0_389: + WORD $0xb100041f // cmn x0, #1 + WORD $0x54000281 // b.ne LBB0_399 $80(%rip) +LBB0_390: + WORD $0x92800000 // mov x0, #-1 + WORD $0xaa0f03f8 // mov x24, x15 + WORD $0x14000011 // b LBB0_399 $68(%rip) +LBB0_391: + WORD $0x92800013 // mov x19, #-1 +LBB0_392: + WORD $0xaa3303e9 // mvn x9, x19 + WORD $0x8b090108 // add x8, x8, x9 +LBB0_393: + WORD $0xf9000028 // str x8, [x1] +LBB0_394: + WORD $0x9280002f // mov x15, #-2 + WORD $0x1400000d // b LBB0_400 $52(%rip) +LBB0_395: + WORD $0xb100071f // cmn x24, #1 + WORD $0x540000a0 // b.eq LBB0_398 $20(%rip) + WORD $0x92800020 // mov x0, #-2 + WORD $0x14000007 // b LBB0_399 $28(%rip) +LBB0_397: + WORD $0xf900002a // str x10, [x1] + WORD $0x17ffffec // b LBB0_387 $-80(%rip) +LBB0_398: + WORD $0xdac00148 // rbit x8, x10 + WORD $0xdac01108 // clz x8, x8 + WORD $0x8b000118 // add x24, x8, x0 + WORD $0x92800020 // mov x0, #-2 +LBB0_399: + WORD $0xf9000038 // str x24, [x1] + WORD $0xaa0003ef // mov x15, x0 +LBB0_400: + WORD $0xaa0f03e0 // mov x0, x15 + WORD $0xa9497bfd // ldp x29, x30, [sp, #144] + WORD $0xa9484ff4 // ldp x20, x19, [sp, #128] + WORD $0xa94757f6 // ldp x22, x21, [sp, #112] + WORD $0xa9465ff8 // ldp x24, x23, [sp, #96] + WORD $0xa94567fa // ldp x26, x25, [sp, #80] + WORD $0xa9446ffc // ldp x28, x27, [sp, #64] + WORD $0x910283ff // add sp, sp, #160 + WORD $0xd65f03c0 // ret +LBB0_401: + WORD $0x9280001b // mov x27, #-1 +LBB0_402: + WORD $0xcb1b0108 // sub x8, x8, x27 + WORD $0x17ffffe6 // b LBB0_393 $-104(%rip) +LBB0_403: + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x7101855f // cmp w10, #97 + WORD $0x54fffc81 // b.ne LBB0_394 $-112(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101b15f // cmp w10, #108 + WORD $0x54fffbe1 // b.ne LBB0_394 $-132(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101cd5f // cmp w10, #115 + WORD $0x54fffb41 // b.ne LBB0_394 $-152(%rip) + WORD $0x9100110a // add x10, x8, #4 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101953f // cmp w9, #101 + WORD $0x54fffaa1 // b.ne LBB0_394 $-172(%rip) + WORD $0x91001508 // add x8, x8, #5 + WORD $0x17ffffd2 // b LBB0_393 $-184(%rip) +LBB0_408: + WORD $0xf9000028 // str x8, [x1] + WORD $0x3940030a // ldrb w10, [x24] + WORD $0x7101b95f // cmp w10, #110 + WORD $0x54fff9e1 // b.ne LBB0_394 $-196(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101d55f // cmp w10, #117 + WORD $0x54fff941 // b.ne LBB0_394 $-216(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101b15f // cmp w10, #108 + WORD $0x54fff8a1 // b.ne LBB0_394 $-236(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101b13f // cmp w9, #108 + WORD $0x54fff801 // b.ne LBB0_394 $-256(%rip) + WORD $0x14000014 // b LBB0_416 $80(%rip) +LBB0_412: + WORD $0xf9000028 // str x8, [x1] + WORD $0x3940030a // ldrb w10, [x24] + WORD $0x7101d15f // cmp w10, #116 + WORD $0x54fff761 // b.ne LBB0_394 $-276(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101c95f // cmp w10, #114 + WORD $0x54fff6c1 // b.ne LBB0_394 $-296(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101d55f // cmp w10, #117 + WORD $0x54fff621 // b.ne LBB0_394 $-316(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101953f // cmp w9, #101 + WORD $0x54fff581 // b.ne LBB0_394 $-336(%rip) +LBB0_416: + WORD $0x91001108 // add x8, x8, #4 + WORD $0x17ffffa9 // b LBB0_393 $-348(%rip) +LBB0_417: + WORD $0xaa0003ef // mov x15, x0 + WORD $0x17ffffa1 // b LBB0_390 $-380(%rip) +LBB0_418: + WORD $0x8b000158 // add x24, x10, x0 + WORD $0x92800020 // mov x0, #-2 + WORD $0x17ffffb1 // b LBB0_399 $-316(%rip) +LBB0_419: + WORD $0xcb090008 // sub x8, x0, x9 + WORD $0x8b0a0118 // add x24, x8, x10 + WORD $0x92800020 // mov x0, #-2 + WORD $0x17ffffad // b LBB0_399 $-332(%rip) +LBB0_420: + WORD $0xcb090018 // sub x24, x0, x9 + WORD $0x92800020 // mov x0, #-2 + WORD $0x17ffffaa // b LBB0_399 $-344(%rip) + // .p2align 1, 0x00 +LJTI0_0: + WORD $0x00050000 + WORD $0x006d000e + WORD $0x01070071 + // // .word (LBB0_32-LBB0_32)>>2 +// .word (LBB0_34-LBB0_32)>>2 +// .word (LBB0_37-LBB0_32)>>2 +// .word (LBB0_49-LBB0_32)>>2 +// .word (LBB0_51-LBB0_32)>>2 +// .word (LBB0_87-LBB0_32)>>2 + +LJTI0_1: + WORD $0x06c006ce + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c00213 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x027006c0 + WORD $0x06c006c0 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x027b06c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c00283 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c0028e + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c00298 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x02a306c0 + // // .word (LBB0_400-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_151-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_162-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_166-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_168-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_171-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_173-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_176-LBB0_56)>>2 + +LJTI0_2: + WORD $0x12001e00 + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x00181e1e + // // .byte (LBB0_212-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_212-LBB0_212)>>2 +// .byte (LBB0_218-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_221-LBB0_212)>>2 + +LJTI0_3: + WORD $0x01070013 + WORD $0x00170013 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x00000000 + // // .word (LBB0_85-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_85-LBB0_80)>>2 +// .word (LBB0_86-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_80-LBB0_80)>>2 + +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__skip_array(SB), $0-40 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $192, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_skip_array: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + MOVD m+16(FP), R2 + MOVD flags+24(FP), R3 + CALL ·__skip_array_arm64_entry__+76(SB) // _skip_array + MOVD R0, ret+32(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/skip_array_subr_arm64.go b/internal/native/neon/skip_array_subr_arm64.go new file mode 100644 index 000000000..1243ca699 --- /dev/null +++ b/internal/native/neon/skip_array_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __skip_array_arm64_entry__() uintptr + +var ( + _subr__skip_array uintptr = __skip_array_arm64_entry__() + 64 +) + +const ( + _stack__skip_array = 160 +) + +var ( + _ = _subr__skip_array +) + +const ( + _ = _stack__skip_array +) diff --git a/internal/native/neon/skip_number_arm64.go b/internal/native/neon/skip_number_arm64.go new file mode 100644 index 000000000..b118ab113 --- /dev/null +++ b/internal/native/neon/skip_number_arm64.go @@ -0,0 +1,31 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +//go:nosplit +func skip_number(s *string, p *int) (ret int) { + return __skip_number(s, p) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_number(s *string, p *int) (ret int) diff --git a/internal/native/neon/skip_number_arm64.s b/internal/native/neon/skip_number_arm64.s new file mode 100644 index 000000000..320d971ef --- /dev/null +++ b/internal/native/neon/skip_number_arm64.s @@ -0,0 +1,404 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__skip_number_arm64_entry__(SB), NOSPLIT, $32 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_1: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_skip_number: + MOVD.W R30, -48(RSP) // WORD $0xf81d0ffe // str x30, [sp, #-48]! + WORD $0xa9024ff4 // stp x20, x19, [sp, #32] + WORD $0xa9402808 // ldp x8, x10, [x0] + WORD $0xf9400020 // ldr x0, [x1] + WORD $0x8b000109 // add x9, x8, x0 + WORD $0xaa0903eb // mov x11, x9 + WORD $0x3840156c // ldrb w12, [x11], #1 + WORD $0x7100b59f // cmp w12, #45 + WORD $0x1a9f17ee // cset w14, eq + WORD $0x9a8b1129 // csel x9, x9, x11, ne + WORD $0xcb00014a // sub x10, x10, x0 + WORD $0xeb0e014f // subs x15, x10, x14 + WORD $0x54001c60 // b.eq LBB0_56 $908(%rip) + WORD $0x3940012a // ldrb w10, [x9] + WORD $0x5100e94b // sub w11, w10, #58 + WORD $0x3100297f // cmn w11, #10 + WORD $0x54001863 // b.lo LBB0_50 $780(%rip) + WORD $0x7100c15f // cmp w10, #48 + WORD $0x54000281 // b.ne LBB0_6 $80(%rip) + WORD $0xf10005ff // cmp x15, #1 + WORD $0x54000101 // b.ne LBB0_5 $32(%rip) +LBB0_4: + WORD $0x5280002e // mov w14, #1 + WORD $0x8b0e0129 // add x9, x9, x14 + WORD $0xcb080128 // sub x8, x9, x8 + WORD $0xf9000028 // str x8, [x1] + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_5: + WORD $0x3940052a // ldrb w10, [x9, #1] + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x5280002b // mov w11, #1 + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xb20903eb // mov x11, #36028797027352576 + WORD $0xf280002b // movk x11, #1 + WORD $0x8a0b014a // and x10, x10, x11 + WORD $0xfa409944 // ccmp x10, #0, #4, ls + WORD $0x54fffe00 // b.eq LBB0_4 $-64(%rip) +LBB0_6: + WORD $0xf10041ff // cmp x15, #16 + WORD $0x540019c3 // b.lo LBB0_57 $824(%rip) + WORD $0xd2800010 // mov x16, #0 + WORD $0x9280000a // mov x10, #-1 + WORD $0x4f01e5c0 // movi.16b v0, #46 + WORD $0x4f01e561 // movi.16b v1, #43 + WORD $0x4f01e5a2 // movi.16b v2, #45 + WORD $0x4f06e603 // movi.16b v3, #208 +Lloh0: + WORD $0x10fff94b // adr x11, lCPI0_0 $-216(%rip) +Lloh1: + WORD $0x3dc00164 // ldr q4, [x11, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x4f00e545 // movi.16b v5, #10 + WORD $0x4f06e7e6 // movi.16b v6, #223 +Lloh2: + WORD $0x10fff94b // adr x11, lCPI0_1 $-216(%rip) +Lloh3: + WORD $0x3dc00167 // ldr q7, [x11, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x4f02e4b0 // movi.16b v16, #69 + WORD $0x12800011 // mov w17, #-1 + WORD $0x9280000c // mov x12, #-1 + WORD $0x9280000b // mov x11, #-1 + WORD $0xaa0f03ed // mov x13, x15 +LBB0_8: + WORD $0x3cf06931 // ldr q17, [x9, x16] + WORD $0x6e208e32 // cmeq.16b v18, v17, v0 + WORD $0x6e218e33 // cmeq.16b v19, v17, v1 + WORD $0x6e228e34 // cmeq.16b v20, v17, v2 + WORD $0x4e238635 // add.16b v21, v17, v3 + WORD $0x6e3534b5 // cmhi.16b v21, v5, v21 + WORD $0x4e261e31 // and.16b v17, v17, v6 + WORD $0x6e308e31 // cmeq.16b v17, v17, v16 + WORD $0x4eb31e93 // orr.16b v19, v20, v19 + WORD $0x4eb21e34 // orr.16b v20, v17, v18 + WORD $0x4eb31e94 // orr.16b v20, v20, v19 + WORD $0x4eb51e94 // orr.16b v20, v20, v21 + WORD $0x4e241e52 // and.16b v18, v18, v4 + WORD $0x4e070252 // tbl.16b v18, { v18 }, v7 + WORD $0x4e71ba52 // addv.8h h18, v18 + WORD $0x1e260243 // fmov w3, s18 + WORD $0x4e241e31 // and.16b v17, v17, v4 + WORD $0x4e070231 // tbl.16b v17, { v17 }, v7 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260224 // fmov w4, s17 + WORD $0x4e241e71 // and.16b v17, v19, v4 + WORD $0x4e070231 // tbl.16b v17, { v17 }, v7 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260226 // fmov w6, s17 + WORD $0x4e241e91 // and.16b v17, v20, v4 + WORD $0x4e070231 // tbl.16b v17, { v17 }, v7 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260222 // fmov w2, s17 + WORD $0x2a2203e2 // mvn w2, w2 + WORD $0x32103c42 // orr w2, w2, #0xffff0000 + WORD $0x5ac00042 // rbit w2, w2 + WORD $0x5ac01042 // clz w2, w2 + WORD $0x1ac22225 // lsl w5, w17, w2 + WORD $0x0a250067 // bic w7, w3, w5 + WORD $0x0a250093 // bic w19, w4, w5 + WORD $0x0a2500d4 // bic w20, w6, w5 + WORD $0x7100405f // cmp w2, #16 + WORD $0x1a870065 // csel w5, w3, w7, eq + WORD $0x1a930084 // csel w4, w4, w19, eq + WORD $0x1a9400c3 // csel w3, w6, w20, eq + WORD $0x510004a6 // sub w6, w5, #1 + WORD $0x6a0500c6 // ands w6, w6, w5 + WORD $0x54000fc1 // b.ne LBB0_52 $504(%rip) + WORD $0x51000486 // sub w6, w4, #1 + WORD $0x6a0400c6 // ands w6, w6, w4 + WORD $0x54000f61 // b.ne LBB0_52 $492(%rip) + WORD $0x51000466 // sub w6, w3, #1 + WORD $0x6a0300c6 // ands w6, w6, w3 + WORD $0x54000f01 // b.ne LBB0_52 $480(%rip) + WORD $0x340000c5 // cbz w5, LBB0_14 $24(%rip) + WORD $0x5ac000a5 // rbit w5, w5 + WORD $0x5ac010a5 // clz w5, w5 + WORD $0xb100057f // cmn x11, #1 + WORD $0x54000f01 // b.ne LBB0_53 $480(%rip) + WORD $0x8b05020b // add x11, x16, x5 +LBB0_14: + WORD $0x340000c4 // cbz w4, LBB0_17 $24(%rip) + WORD $0x5ac00084 // rbit w4, w4 + WORD $0x5ac01084 // clz w4, w4 + WORD $0xb100059f // cmn x12, #1 + WORD $0x54000ea1 // b.ne LBB0_54 $468(%rip) + WORD $0x8b04020c // add x12, x16, x4 +LBB0_17: + WORD $0x340000c3 // cbz w3, LBB0_20 $24(%rip) + WORD $0x5ac00063 // rbit w3, w3 + WORD $0x5ac01063 // clz w3, w3 + WORD $0xb100055f // cmn x10, #1 + WORD $0x54000e41 // b.ne LBB0_55 $456(%rip) + WORD $0x8b03020a // add x10, x16, x3 +LBB0_20: + WORD $0x7100405f // cmp w2, #16 + WORD $0x540005e1 // b.ne LBB0_32 $188(%rip) + WORD $0xd10041ad // sub x13, x13, #16 + WORD $0x91004210 // add x16, x16, #16 + WORD $0xf1003dbf // cmp x13, #15 + WORD $0x54fff708 // b.hi LBB0_8 $-288(%rip) + WORD $0x8b100131 // add x17, x9, x16 + WORD $0xeb1001ff // cmp x15, x16 + WORD $0x54000540 // b.eq LBB0_33 $168(%rip) +LBB0_23: + WORD $0x8b0d022f // add x15, x17, x13 + WORD $0x8b080010 // add x16, x0, x8 + WORD $0x8b0e020e // add x14, x16, x14 + WORD $0xaa3103f0 // mvn x16, x17 + WORD $0x8b0e020e // add x14, x16, x14 + WORD $0xcb090230 // sub x16, x17, x9 + WORD $0xaa1103e2 // mov x2, x17 +Lloh4: + WORD $0x10000de3 // adr x3, LJTI0_0 $444(%rip) +Lloh5: + WORD $0x91000063 // add x3, x3, LJTI0_0@PAGEOFF $0(%rip) + WORD $0x1400000b // b LBB0_27 $44(%rip) +LBB0_24: + WORD $0x7101949f // cmp w4, #101 + WORD $0x540003c1 // b.ne LBB0_33 $120(%rip) +LBB0_25: + WORD $0xb100059f // cmn x12, #1 + WORD $0xaa1003ec // mov x12, x16 + WORD $0x540005c1 // b.ne LBB0_43 $184(%rip) +LBB0_26: + WORD $0xd10005ce // sub x14, x14, #1 + WORD $0x91000610 // add x16, x16, #1 + WORD $0xaa0203f1 // mov x17, x2 + WORD $0xd10005ad // sub x13, x13, #1 + WORD $0xb40006cd // cbz x13, LBB0_48 $216(%rip) +LBB0_27: + WORD $0x38c01444 // ldrsb w4, [x2], #1 + WORD $0x5100c085 // sub w5, w4, #48 + WORD $0x710028bf // cmp w5, #10 + WORD $0x54ffff03 // b.lo LBB0_26 $-32(%rip) + WORD $0x5100ac85 // sub w5, w4, #43 + WORD $0x710068bf // cmp w5, #26 + WORD $0x54fffe08 // b.hi LBB0_24 $-64(%rip) + WORD $0x10fffe24 // adr x4, LBB0_25 $-60(%rip) + WORD $0x38656866 // ldrb w6, [x3, x5] + WORD $0x8b060884 // add x4, x4, x6, lsl #2 + WORD $0xd61f0080 // br x4 +LBB0_30: + WORD $0xb100055f // cmn x10, #1 + WORD $0xaa1003ea // mov x10, x16 + WORD $0x54fffdc0 // b.eq LBB0_26 $-72(%rip) + WORD $0x1400001a // b LBB0_43 $104(%rip) +LBB0_31: + WORD $0xb100057f // cmn x11, #1 + WORD $0xaa1003eb // mov x11, x16 + WORD $0x54fffd40 // b.eq LBB0_26 $-88(%rip) + WORD $0x14000016 // b LBB0_43 $88(%rip) +LBB0_32: + WORD $0x8b22412d // add x13, x9, w2, uxtw + WORD $0x8b1001b1 // add x17, x13, x16 +LBB0_33: + WORD $0x9280000e // mov x14, #-1 + WORD $0xb400044b // cbz x11, LBB0_49 $136(%rip) +LBB0_34: + WORD $0xb400042a // cbz x10, LBB0_49 $132(%rip) + WORD $0xb400040c // cbz x12, LBB0_49 $128(%rip) + WORD $0xcb09022d // sub x13, x17, x9 + WORD $0xd10005ae // sub x14, x13, #1 + WORD $0xeb0e017f // cmp x11, x14 + WORD $0x54000160 // b.eq LBB0_42 $44(%rip) + WORD $0xeb0e015f // cmp x10, x14 + WORD $0x54000120 // b.eq LBB0_42 $36(%rip) + WORD $0xeb0e019f // cmp x12, x14 + WORD $0x540000e0 // b.eq LBB0_42 $28(%rip) + WORD $0xf100054e // subs x14, x10, #1 + WORD $0x540001ab // b.lt LBB0_45 $52(%rip) + WORD $0xeb0e019f // cmp x12, x14 + WORD $0x54000160 // b.eq LBB0_45 $44(%rip) + WORD $0xaa2a03ee // mvn x14, x10 + WORD $0x14000002 // b LBB0_43 $8(%rip) +LBB0_42: + WORD $0xcb0d03ee // neg x14, x13 +LBB0_43: + WORD $0xb7f8020e // tbnz x14, #63, LBB0_49 $64(%rip) + WORD $0x8b0e0129 // add x9, x9, x14 + WORD $0xcb080128 // sub x8, x9, x8 + WORD $0xf9000028 // str x8, [x1] + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_45: + WORD $0xaa0c016a // orr x10, x11, x12 + WORD $0xb7f8020a // tbnz x10, #63, LBB0_51 $64(%rip) + WORD $0xeb0c017f // cmp x11, x12 + WORD $0x540001cb // b.lt LBB0_51 $56(%rip) + WORD $0xaa2b03ee // mvn x14, x11 + WORD $0x17fffff4 // b LBB0_43 $-48(%rip) +LBB0_48: + WORD $0xaa0f03f1 // mov x17, x15 + WORD $0x9280000e // mov x14, #-1 + WORD $0xb5fffc0b // cbnz x11, LBB0_34 $-128(%rip) +LBB0_49: + WORD $0xaa2e03ea // mvn x10, x14 + WORD $0x8b0a0129 // add x9, x9, x10 +LBB0_50: + WORD $0x92800020 // mov x0, #-2 + WORD $0xcb080128 // sub x8, x9, x8 + WORD $0xf9000028 // str x8, [x1] + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_51: + WORD $0xd37ffd4a // lsr x10, x10, #63 + WORD $0x5200014a // eor w10, w10, #0x1 + WORD $0xd100058e // sub x14, x12, #1 + WORD $0xeb0e017f // cmp x11, x14 + WORD $0x1a9f17eb // cset w11, eq + WORD $0x6a0b015f // tst w10, w11 + WORD $0xda8c01ae // csinv x14, x13, x12, eq + WORD $0x17ffffe1 // b LBB0_43 $-124(%rip) +LBB0_52: + WORD $0x5ac000ca // rbit w10, w6 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3003eb // mvn x11, x16 + WORD $0xcb0a016e // sub x14, x11, x10 + WORD $0x17ffffdc // b LBB0_43 $-144(%rip) +LBB0_53: + WORD $0xaa3003ea // mvn x10, x16 + WORD $0xcb25414e // sub x14, x10, w5, uxtw + WORD $0x17ffffd9 // b LBB0_43 $-156(%rip) +LBB0_54: + WORD $0xaa3003ea // mvn x10, x16 + WORD $0xcb24414e // sub x14, x10, w4, uxtw + WORD $0x17ffffd6 // b LBB0_43 $-168(%rip) +LBB0_55: + WORD $0xaa3003ea // mvn x10, x16 + WORD $0xcb23414e // sub x14, x10, w3, uxtw + WORD $0x17ffffd3 // b LBB0_43 $-180(%rip) +LBB0_56: + WORD $0x92800000 // mov x0, #-1 + WORD $0xcb080128 // sub x8, x9, x8 + WORD $0xf9000028 // str x8, [x1] + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_57: + WORD $0x9280000b // mov x11, #-1 + WORD $0xaa0903f1 // mov x17, x9 + WORD $0xaa0f03ed // mov x13, x15 + WORD $0x9280000c // mov x12, #-1 + WORD $0x9280000a // mov x10, #-1 + WORD $0x17ffff8b // b LBB0_23 $-468(%rip) +LJTI0_0: + WORD $0x17131d13 + WORD $0x1d1d1d1d + WORD $0x1d1d1d1d + WORD $0x1d1d1d1d + WORD $0x1d1d1d1d + WORD $0x1d1d1d1d + WORD $0x00001d1d + // // .byte (LBB0_30-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_30-LBB0_25)>>2 +// .byte (LBB0_31-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_33-LBB0_25)>>2 +// .byte (LBB0_25-LBB0_25)>>2 + +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__skip_number(SB), $0-24 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $80, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_skip_number: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + CALL ·__skip_number_arm64_entry__+60(SB) // _skip_number + MOVD R0, ret+16(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/skip_number_subr_arm64.go b/internal/native/neon/skip_number_subr_arm64.go new file mode 100644 index 000000000..48b5681ea --- /dev/null +++ b/internal/native/neon/skip_number_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __skip_number_arm64_entry__() uintptr + +var ( + _subr__skip_number uintptr = __skip_number_arm64_entry__() + 48 +) + +const ( + _stack__skip_number = 48 +) + +var ( + _ = _subr__skip_number +) + +const ( + _ = _stack__skip_number +) diff --git a/internal/native/neon/skip_object_arm64.go b/internal/native/neon/skip_object_arm64.go new file mode 100644 index 000000000..8e3efa638 --- /dev/null +++ b/internal/native/neon/skip_object_arm64.go @@ -0,0 +1,37 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + // `unsafe` + + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) { + return __skip_object(s, p, m, flags) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) diff --git a/internal/native/neon/skip_object_arm64.s b/internal/native/neon/skip_object_arm64.s new file mode 100644 index 000000000..6a0b53ff1 --- /dev/null +++ b/internal/native/neon/skip_object_arm64.s @@ -0,0 +1,2702 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__skip_object_arm64_entry__(SB), NOSPLIT, $144 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910283ff // add sp, sp, #160 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x00000001; WORD $0x00000000 // .quad 1 + WORD $0x00000006; WORD $0x00000000 // .quad 6 +lCPI0_1: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_2: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_skip_object: + MOVD.W R30, -160(RSP) // WORD $0xf8160ffe // str x30, [sp, #-160]! + WORD $0xa9046ffc // stp x28, x27, [sp, #64] + WORD $0xa90567fa // stp x26, x25, [sp, #80] + WORD $0xa9065ff8 // stp x24, x23, [sp, #96] + WORD $0xa90757f6 // stp x22, x21, [sp, #112] + WORD $0xa9084ff4 // stp x20, x19, [sp, #128] + WORD $0xa9097bfd // stp x29, x30, [sp, #144] + WORD $0xaa0003e6 // mov x6, x0 +Lloh0: + WORD $0x10fffd88 // adr x8, lCPI0_0 $-80(%rip) +Lloh1: + WORD $0x3dc00100 // ldr q0, [x8, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x3d800040 // str q0, [x2] + WORD $0xf9400009 // ldr x9, [x0] + WORD $0xaa2903e8 // mvn x8, x9 + WORD $0xf90013e8 // str x8, [sp, #32] + WORD $0x5280002b // mov w11, #1 + WORD $0xcb090168 // sub x8, x11, x9 + WORD $0xf90017e8 // str x8, [sp, #40] + WORD $0xf9400020 // ldr x0, [x1] + WORD $0xcb0903e8 // neg x8, x9 + WORD $0xf9001be8 // str x8, [sp, #48] + WORD $0xd1000528 // sub x8, x9, #1 + WORD $0xf9001fe8 // str x8, [sp, #56] + WORD $0x92800017 // mov x23, #-1 + WORD $0xd284c010 // mov x16, #9728 + WORD $0xf2c00030 // movk x16, #1, lsl #32 + WORD $0x4f01e440 // movi.16b v0, #34 + WORD $0x4f02e781 // movi.16b v1, #92 +Lloh2: + WORD $0x10fffba8 // adr x8, lCPI0_1 $-140(%rip) +Lloh3: + WORD $0x3dc00102 // ldr q2, [x8, lCPI0_1@PAGEOFF] $0(%rip) +Lloh4: + WORD $0x10fffbe8 // adr x8, lCPI0_2 $-132(%rip) +Lloh5: + WORD $0x3dc00103 // ldr q3, [x8, lCPI0_2@PAGEOFF] $0(%rip) + WORD $0x4f01e404 // movi.16b v4, #32 + WORD $0x4f01e5c5 // movi.16b v5, #46 + WORD $0x4f01e566 // movi.16b v6, #43 +Lloh6: + WORD $0x10010974 // adr x20, LJTI0_2 $8492(%rip) +Lloh7: + WORD $0x91000294 // add x20, x20, LJTI0_2@PAGEOFF $0(%rip) + WORD $0x12800015 // mov w21, #-1 + WORD $0x4f01e5a7 // movi.16b v7, #45 + WORD $0x4f06e610 // movi.16b v16, #208 +Lloh8: + WORD $0x100109b6 // adr x22, LJTI0_3 $8500(%rip) +Lloh9: + WORD $0x910002d6 // add x22, x22, LJTI0_3@PAGEOFF $0(%rip) + WORD $0x4f00e551 // movi.16b v17, #10 + WORD $0x4f06e7f2 // movi.16b v18, #223 + WORD $0x4f02e4b3 // movi.16b v19, #69 + WORD $0x52800039 // mov w25, #1 +Lloh10: + WORD $0x1000ffe4 // adr x4, LJTI0_0 $8188(%rip) +Lloh11: + WORD $0x91000084 // add x4, x4, LJTI0_0@PAGEOFF $0(%rip) + WORD $0x14000009 // b LBB0_4 $36(%rip) +LBB0_1: + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x5280008a // mov w10, #4 +LBB0_2: + WORD $0xf900050a // str x10, [x8, #8] +LBB0_3: + WORD $0xf9400059 // ldr x25, [x2] + WORD $0xaa1703ef // mov x15, x23 + WORD $0xb400f419 // cbz x25, LBB0_400 $7808(%rip) +LBB0_4: + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0f001f // cmp x0, x15 + WORD $0x54000162 // b.hs LBB0_9 $44(%rip) + WORD $0x38606928 // ldrb w8, [x9, x0] + WORD $0x7100351f // cmp w8, #13 + WORD $0x54000100 // b.eq LBB0_9 $32(%rip) + WORD $0x7100811f // cmp w8, #32 + WORD $0x540000c0 // b.eq LBB0_9 $24(%rip) + WORD $0x51002d08 // sub w8, w8, #11 + WORD $0x3100091f // cmn w8, #2 + WORD $0x54000062 // b.hs LBB0_9 $12(%rip) + WORD $0xaa0003e8 // mov x8, x0 + WORD $0x14000035 // b LBB0_29 $212(%rip) +LBB0_9: + WORD $0x91000408 // add x8, x0, #1 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_13 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_13 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_13 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x54000543 // b.lo LBB0_29 $168(%rip) +LBB0_13: + WORD $0x91000808 // add x8, x0, #2 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_17 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_17 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_17 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x540003e3 // b.lo LBB0_29 $124(%rip) +LBB0_17: + WORD $0x91000c08 // add x8, x0, #3 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_21 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_21 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_21 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x54000283 // b.lo LBB0_29 $80(%rip) +LBB0_21: + WORD $0x91001008 // add x8, x0, #4 + WORD $0xeb0801ff // cmp x15, x8 + WORD $0x5400ea69 // b.ls LBB0_386 $7500(%rip) + WORD $0x54000180 // b.eq LBB0_26 $48(%rip) + WORD $0x8b0f012a // add x10, x9, x15 +LBB0_24: + WORD $0x38e8692c // ldrsb w12, [x9, x8] + WORD $0x7100819f // cmp w12, #32 + WORD $0x9acc216c // lsl x12, x11, x12 + WORD $0x8a10018c // and x12, x12, x16 + WORD $0xfa409984 // ccmp x12, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_28 $28(%rip) + WORD $0x91000508 // add x8, x8, #1 + WORD $0xeb0801ff // cmp x15, x8 + WORD $0x54ffff01 // b.ne LBB0_24 $-32(%rip) + WORD $0x14000002 // b LBB0_27 $8(%rip) +LBB0_26: + WORD $0x8b08012a // add x10, x9, x8 +LBB0_27: + WORD $0xcb090148 // sub x8, x10, x9 +LBB0_28: + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x5400e882 // b.hs LBB0_387 $7440(%rip) +LBB0_29: + WORD $0x91000500 // add x0, x8, #1 + WORD $0xf9000020 // str x0, [x1] + WORD $0x8b080138 // add x24, x9, x8 + WORD $0x39c00307 // ldrsb w7, [x24] + WORD $0x3400e7e7 // cbz w7, LBB0_387 $7420(%rip) + WORD $0xd100072a // sub x10, x25, #1 + WORD $0x8b0a0c4c // add x12, x2, x10, lsl #3 + WORD $0xb8408d8d // ldr w13, [x12, #8]! + WORD $0xb10006ff // cmn x23, #1 + WORD $0x9a970117 // csel x23, x8, x23, eq + WORD $0x510005ad // sub w13, w13, #1 + WORD $0x710015bf // cmp w13, #5 + WORD $0x54000f48 // b.hi LBB0_53 $488(%rip) + WORD $0x1000008f // adr x15, LBB0_32 $16(%rip) + WORD $0x786d7893 // ldrh w19, [x4, x13, lsl #1] + WORD $0x8b1309ef // add x15, x15, x19, lsl #2 + WORD $0xd61f01e0 // br x15 +LBB0_32: + WORD $0x7100b0ff // cmp w7, #44 + WORD $0x540021e0 // b.eq LBB0_90 $1084(%rip) + WORD $0x710174ff // cmp w7, #93 + WORD $0x54002100 // b.eq LBB0_89 $1056(%rip) + WORD $0x1400073b // b LBB0_394 $7404(%rip) +LBB0_34: + WORD $0x7100b0ff // cmp w7, #44 + WORD $0x54002061 // b.ne LBB0_88 $1036(%rip) + WORD $0xf13fff3f // cmp x25, #4095 + WORD $0x5400e58c // b.gt LBB0_388 $7344(%rip) + WORD $0x91000728 // add x8, x25, #1 + WORD $0xf9000048 // str x8, [x2] + WORD $0x8b190c48 // add x8, x2, x25, lsl #3 + WORD $0x5280006a // mov w10, #3 + WORD $0x17ffff9d // b LBB0_2 $-396(%rip) +LBB0_37: + WORD $0x710088ff // cmp w7, #34 + WORD $0x5400e601 // b.ne LBB0_394 $7360(%rip) + WORD $0x5280008a // mov w10, #4 + WORD $0xf900018a // str x10, [x12] + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0001fa // subs x26, x15, x0 + WORD $0x37282c03 // tbnz w3, #5, LBB0_103 $1408(%rip) + WORD $0x5400f020 // b.eq LBB0_417 $7684(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x5400b8a3 // b.lo LBB0_315 $5908(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_42: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405554 // ldp q20, q21, [x10] + WORD $0xad415d56 // ldp q22, q23, [x10, #32] + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e208efb // cmeq.16b v27, v23, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x6e218ef7 // cmeq.16b v23, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x4e221f38 // and.16b v24, v25, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x4e221f58 // and.16b v24, v26, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x4e221f78 // and.16b v24, v27, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260293 // fmov w19, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26029c // fmov w28, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xd3607e6c // lsl x12, x19, #32 + WORD $0xb3503f8c // bfi x12, x28, #48, #16 + WORD $0x53103ced // lsl w13, w7, #16 + WORD $0xaa0d018c // orr x12, x12, x13 + WORD $0xaa11018c // orr x12, x12, x17 + WORD $0xb500010c // cbnz x12, LBB0_46 $32(%rip) + WORD $0xb50001bb // cbnz x27, LBB0_47 $52(%rip) + WORD $0xb50002ea // cbnz x10, LBB0_48 $92(%rip) +LBB0_45: + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff8a8 // b.hi LBB0_42 $-236(%rip) + WORD $0x140003f7 // b LBB0_238 $4060(%rip) +LBB0_46: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0018d // rbit x13, x12 + WORD $0xdac011ad // clz x13, x13 + WORD $0x8b0001ad // add x13, x13, x0 + WORD $0x9a8d1318 // csel x24, x24, x13, ne + WORD $0x9a8d1339 // csel x25, x25, x13, ne +LBB0_47: + WORD $0x8a3b018d // bic x13, x12, x27 + WORD $0xaa0d076e // orr x14, x27, x13, lsl #1 + WORD $0x8a2e018c // bic x12, x12, x14 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0d018c // adds x12, x12, x13 + WORD $0x1a9f37fb // cset w27, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0e018c // and x12, x12, x14 + WORD $0x8a2c014a // bic x10, x10, x12 + WORD $0xb4fffd6a // cbz x10, LBB0_45 $-84(%rip) +LBB0_48: + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x1400017d // b LBB0_115 $1524(%rip) +LBB0_49: + WORD $0x7100e8ff // cmp w7, #58 + WORD $0x5400da21 // b.ne LBB0_394 $6980(%rip) + WORD $0xf900019f // str xzr, [x12] + WORD $0x17ffff3b // b LBB0_3 $-788(%rip) +LBB0_51: + WORD $0x710174ff // cmp w7, #93 + WORD $0x54001320 // b.eq LBB0_89 $612(%rip) + WORD $0xf900018b // str x11, [x12] + WORD $0x14000002 // b LBB0_54 $8(%rip) +LBB0_53: + WORD $0xf900004a // str x10, [x2] +LBB0_54: + WORD $0x7101ecff // cmp w7, #123 + WORD $0x5400d908 // b.hi LBB0_394 $6944(%rip) + WORD $0x9280000f // mov x15, #-1 +Lloh12: + WORD $0x1000e58d // adr x13, LJTI0_1 $7344(%rip) +Lloh13: + WORD $0x910001ad // add x13, x13, LJTI0_1@PAGEOFF $0(%rip) + WORD $0x1000008a // adr x10, LBB0_56 $16(%rip) + WORD $0x786779ac // ldrh w12, [x13, x7, lsl #1] + WORD $0x8b0c094a // add x10, x10, x12, lsl #2 + WORD $0xd61f0140 // br x10 +LBB0_56: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xeb080153 // subs x19, x10, x8 + WORD $0x5400d740 // b.eq LBB0_391 $6888(%rip) + WORD $0x3940030a // ldrb w10, [x24] + WORD $0x7100c15f // cmp w10, #48 + WORD $0x54000181 // b.ne LBB0_61 $48(%rip) + WORD $0xf100067f // cmp x19, #1 + WORD $0x54003040 // b.eq LBB0_131 $1544(%rip) + WORD $0x3860692a // ldrb w10, [x9, x0] + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x54002fc8 // b.hi LBB0_131 $1528(%rip) + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xb20903ec // mov x12, #36028797027352576 + WORD $0xf280002c // movk x12, #1 + WORD $0xea0c015f // tst x10, x12 + WORD $0x54002f20 // b.eq LBB0_131 $1508(%rip) +LBB0_61: + WORD $0xf100427f // cmp x19, #16 + WORD $0x5400a3a3 // b.lo LBB0_301 $5236(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800019 // mov x25, #-1 + WORD $0x92800000 // mov x0, #-1 + WORD $0x9280000f // mov x15, #-1 + WORD $0xaa1303fa // mov x26, x19 +LBB0_63: + WORD $0x3cfb6b14 // ldr q20, [x24, x27] + WORD $0x6e258e95 // cmeq.16b v21, v20, v5 + WORD $0x6e268e96 // cmeq.16b v22, v20, v6 + WORD $0x6e278e97 // cmeq.16b v23, v20, v7 + WORD $0x4e308698 // add.16b v24, v20, v16 + WORD $0x6e383638 // cmhi.16b v24, v17, v24 + WORD $0x4e321e94 // and.16b v20, v20, v18 + WORD $0x6e338e94 // cmeq.16b v20, v20, v19 + WORD $0x4eb61ef6 // orr.16b v22, v23, v22 + WORD $0x4eb51e97 // orr.16b v23, v20, v21 + WORD $0x4eb61ef7 // orr.16b v23, v23, v22 + WORD $0x4eb81ef7 // orr.16b v23, v23, v24 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x2a2c03ec // mvn w12, w12 + WORD $0x32103d8c // orr w12, w12, #0xffff0000 + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac01187 // clz w7, w12 + WORD $0x1ac722ac // lsl w12, w21, w7 + WORD $0x0a2c0151 // bic w17, w10, w12 + WORD $0x0a2c01bc // bic w28, w13, w12 + WORD $0x0a2c01de // bic w30, w14, w12 + WORD $0x710040ff // cmp w7, #16 + WORD $0x1a91014c // csel w12, w10, w17, eq + WORD $0x1a9c01bc // csel w28, w13, w28, eq + WORD $0x1a9e01ca // csel w10, w14, w30, eq + WORD $0x5100058d // sub w13, w12, #1 + WORD $0x6a0c01ad // ands w13, w13, w12 + WORD $0x54007041 // b.ne LBB0_234 $3592(%rip) + WORD $0x5100078d // sub w13, w28, #1 + WORD $0x6a1c01ad // ands w13, w13, w28 + WORD $0x54006fe1 // b.ne LBB0_234 $3580(%rip) + WORD $0x5100054d // sub w13, w10, #1 + WORD $0x6a0a01ad // ands w13, w13, w10 + WORD $0x54006f81 // b.ne LBB0_234 $3568(%rip) + WORD $0x340000cc // cbz w12, LBB0_69 $24(%rip) + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb10005ff // cmn x15, #1 + WORD $0x54007c21 // b.ne LBB0_252 $3972(%rip) + WORD $0x8b0c036f // add x15, x27, x12 +LBB0_69: + WORD $0x340000dc // cbz w28, LBB0_72 $24(%rip) + WORD $0x5ac0038c // rbit w12, w28 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb100041f // cmn x0, #1 + WORD $0x54007b61 // b.ne LBB0_252 $3948(%rip) + WORD $0x8b0c0360 // add x0, x27, x12 +LBB0_72: + WORD $0x340000ca // cbz w10, LBB0_75 $24(%rip) + WORD $0x5ac0014a // rbit w10, w10 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x54008621 // b.ne LBB0_265 $4292(%rip) + WORD $0x8b0a0379 // add x25, x27, x10 +LBB0_75: + WORD $0x710040ff // cmp w7, #16 + WORD $0x540022c1 // b.ne LBB0_118 $1112(%rip) + WORD $0xd100435a // sub x26, x26, #16 + WORD $0x9100437b // add x27, x27, #16 + WORD $0xf1003f5f // cmp x26, #15 + WORD $0x54fff708 // b.hi LBB0_63 $-288(%rip) + WORD $0x8b1b0307 // add x7, x24, x27 + WORD $0xeb1b027f // cmp x19, x27 + WORD $0x54002220 // b.eq LBB0_119 $1092(%rip) +LBB0_78: + WORD $0x8b1a00ea // add x10, x7, x26 + WORD $0xf9401fec // ldr x12, [sp, #56] + WORD $0x8b08018c // add x12, x12, x8 + WORD $0xcb070193 // sub x19, x12, x7 + WORD $0xcb1800fb // sub x27, x7, x24 + WORD $0xaa0703fc // mov x28, x7 + WORD $0x1400000b // b LBB0_82 $44(%rip) +LBB0_79: + WORD $0x7101959f // cmp w12, #101 + WORD $0x54002101 // b.ne LBB0_119 $1056(%rip) +LBB0_80: + WORD $0xb100041f // cmn x0, #1 + WORD $0xaa1b03e0 // mov x0, x27 + WORD $0x54002301 // b.ne LBB0_129 $1120(%rip) +LBB0_81: + WORD $0xd1000673 // sub x19, x19, #1 + WORD $0x9100077b // add x27, x27, #1 + WORD $0xaa1c03e7 // mov x7, x28 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb40056fa // cbz x26, LBB0_191 $2780(%rip) +LBB0_82: + WORD $0x38c0178c // ldrsb w12, [x28], #1 + WORD $0x5100c18d // sub w13, w12, #48 + WORD $0x710029bf // cmp w13, #10 + WORD $0x54ffff03 // b.lo LBB0_81 $-32(%rip) + WORD $0x5100ad8d // sub w13, w12, #43 + WORD $0x710069bf // cmp w13, #26 + WORD $0x54fffe08 // b.hi LBB0_79 $-64(%rip) + WORD $0x10fffe2c // adr x12, LBB0_80 $-60(%rip) + WORD $0x786d7ace // ldrh w14, [x22, x13, lsl #1] + WORD $0x8b0e098c // add x12, x12, x14, lsl #2 + WORD $0xd61f0180 // br x12 +LBB0_85: + WORD $0xb100073f // cmn x25, #1 + WORD $0xaa1b03f9 // mov x25, x27 + WORD $0x54fffdc0 // b.eq LBB0_81 $-72(%rip) + WORD $0x14000104 // b LBB0_129 $1040(%rip) +LBB0_86: + WORD $0xb10005ff // cmn x15, #1 + WORD $0xaa1b03ef // mov x15, x27 + WORD $0x54fffd40 // b.eq LBB0_81 $-88(%rip) + WORD $0x14000100 // b LBB0_129 $1024(%rip) +LBB0_87: + WORD $0x710088ff // cmp w7, #34 + WORD $0x540001e0 // b.eq LBB0_92 $60(%rip) +LBB0_88: + WORD $0x7101f4ff // cmp w7, #125 + WORD $0x5400c6a1 // b.ne LBB0_394 $6356(%rip) +LBB0_89: + WORD $0xf900004a // str x10, [x2] + WORD $0xaa0a03f9 // mov x25, x10 + WORD $0xaa1703ef // mov x15, x23 + WORD $0xb5ffd40a // cbnz x10, LBB0_4 $-1408(%rip) + WORD $0x1400063e // b LBB0_400 $6392(%rip) +LBB0_90: + WORD $0xf13fff3f // cmp x25, #4095 + WORD $0x5400c46c // b.gt LBB0_388 $6284(%rip) + WORD $0x91000728 // add x8, x25, #1 + WORD $0xf9000048 // str x8, [x2] + WORD $0x8b190c48 // add x8, x2, x25, lsl #3 + WORD $0xf900051f // str xzr, [x8, #8] + WORD $0x17fffe95 // b LBB0_3 $-1452(%rip) +LBB0_92: + WORD $0x5280004a // mov w10, #2 + WORD $0xf900018a // str x10, [x12] + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0001fa // subs x26, x15, x0 + WORD $0x37281e23 // tbnz w3, #5, LBB0_132 $964(%rip) + WORD $0x5400cf40 // b.eq LBB0_417 $6632(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x540099e3 // b.lo LBB0_318 $4924(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_96: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405554 // ldp q20, q21, [x10] + WORD $0xad415d56 // ldp q22, q23, [x10, #32] + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e208efb // cmeq.16b v27, v23, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x6e218ef7 // cmeq.16b v23, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x4e221f38 // and.16b v24, v25, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x4e221f58 // and.16b v24, v26, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x4e221f78 // and.16b v24, v27, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260293 // fmov w19, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26029c // fmov w28, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xd3607e6c // lsl x12, x19, #32 + WORD $0xb3503f8c // bfi x12, x28, #48, #16 + WORD $0x53103ced // lsl w13, w7, #16 + WORD $0xaa0d018c // orr x12, x12, x13 + WORD $0xaa11018c // orr x12, x12, x17 + WORD $0xb500010c // cbnz x12, LBB0_100 $32(%rip) + WORD $0xb50001bb // cbnz x27, LBB0_101 $52(%rip) + WORD $0xb50002ea // cbnz x10, LBB0_102 $92(%rip) +LBB0_99: + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff8a8 // b.hi LBB0_96 $-236(%rip) + WORD $0x14000356 // b LBB0_254 $3416(%rip) +LBB0_100: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0018d // rbit x13, x12 + WORD $0xdac011ad // clz x13, x13 + WORD $0x8b0001ad // add x13, x13, x0 + WORD $0x9a8d1318 // csel x24, x24, x13, ne + WORD $0x9a8d1339 // csel x25, x25, x13, ne +LBB0_101: + WORD $0x8a3b018d // bic x13, x12, x27 + WORD $0xaa0d076e // orr x14, x27, x13, lsl #1 + WORD $0x8a2e018c // bic x12, x12, x14 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0d018c // adds x12, x12, x13 + WORD $0x1a9f37fb // cset w27, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0e018c // and x12, x12, x14 + WORD $0x8a2c014a // bic x10, x10, x12 + WORD $0xb4fffd6a // cbz x10, LBB0_99 $-84(%rip) +LBB0_102: + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x1400010e // b LBB0_144 $1080(%rip) +LBB0_103: + WORD $0x5400c440 // b.eq LBB0_417 $6280(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54008da3 // b.lo LBB0_316 $4532(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x9280001b // mov x27, #-1 +LBB0_106: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260307 // fmov w7, s24 + WORD $0x6e218ef8 // cmeq.16b v24, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0x6e218ed8 // cmeq.16b v24, v22, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031e // fmov w30, s24 + WORD $0x6e218eb8 // cmeq.16b v24, v21, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e218e98 // cmeq.16b v24, v20, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503ced // bfi x13, x7, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0193 // orr x19, x12, x10 + WORD $0xd3607e2a // lsl x10, x17, #32 + WORD $0xb3503dca // bfi x10, x14, #48, #16 + WORD $0x53103fcc // lsl w12, w30, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa1c014a // orr x10, x10, x28 + WORD $0xb500044a // cbnz x10, LBB0_111 $136(%rip) + WORD $0xb50004f9 // cbnz x25, LBB0_112 $156(%rip) +LBB0_108: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000313 // cbnz x19, LBB0_113 $96(%rip) + WORD $0xb500aeca // cbnz x10, LBB0_395 $5592(%rip) + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff568 // b.hi LBB0_106 $-340(%rip) + WORD $0x140002a1 // b LBB0_243 $2692(%rip) +LBB0_111: + WORD $0xb100077f // cmn x27, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c137b // csel x27, x27, x12, ne +LBB0_112: + WORD $0x8a39014c // bic x12, x10, x25 + WORD $0xaa0c072d // orr x13, x25, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a0273 // bic x19, x19, x10 + WORD $0x17ffffd0 // b LBB0_108 $-192(%rip) +LBB0_113: + WORD $0xdac0026c // rbit x12, x19 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x5400b623 // b.lo LBB0_418 $5828(%rip) + WORD $0x8b00018a // add x10, x12, x0 +LBB0_115: + WORD $0x91000540 // add x0, x10, #1 +LBB0_116: + WORD $0xb7f8a980 // tbnz x0, #63, LBB0_389 $5424(%rip) +LBB0_117: + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb27ff7ea // mov x10, #9223372036854775806 + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x54ffb789 // b.ls LBB0_3 $-2320(%rip) + WORD $0x1400055d // b LBB0_400 $5492(%rip) +LBB0_118: + WORD $0x8b27430a // add x10, x24, w7, uxtw + WORD $0x8b1b0147 // add x7, x10, x27 +LBB0_119: + WORD $0x92800013 // mov x19, #-1 + WORD $0xb400a90f // cbz x15, LBB0_392 $5408(%rip) +LBB0_120: + WORD $0xb400a8f9 // cbz x25, LBB0_392 $5404(%rip) + WORD $0xb400a8c0 // cbz x0, LBB0_392 $5400(%rip) + WORD $0xcb1800ea // sub x10, x7, x24 + WORD $0xd100054c // sub x12, x10, #1 + WORD $0xeb0c01ff // cmp x15, x12 + WORD $0x54000160 // b.eq LBB0_128 $44(%rip) + WORD $0xeb0c033f // cmp x25, x12 + WORD $0x54000120 // b.eq LBB0_128 $36(%rip) + WORD $0xeb0c001f // cmp x0, x12 + WORD $0x540000e0 // b.eq LBB0_128 $28(%rip) + WORD $0xf100072c // subs x12, x25, #1 + WORD $0x5400118b // b.lt LBB0_148 $560(%rip) + WORD $0xeb0c001f // cmp x0, x12 + WORD $0x54001140 // b.eq LBB0_148 $552(%rip) + WORD $0xaa3903f3 // mvn x19, x25 + WORD $0x14000002 // b LBB0_129 $8(%rip) +LBB0_128: + WORD $0xcb0a03f3 // neg x19, x10 +LBB0_129: + WORD $0xb7f8a6d3 // tbnz x19, #63, LBB0_392 $5336(%rip) + WORD $0x8b080260 // add x0, x19, x8 +LBB0_131: + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb6ffb428 // tbz x8, #63, LBB0_3 $-2428(%rip) + WORD $0x14000542 // b LBB0_400 $5384(%rip) +LBB0_132: + WORD $0x5400b140 // b.eq LBB0_417 $5672(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54007cc3 // b.lo LBB0_319 $3992(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x9280001b // mov x27, #-1 +LBB0_135: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x6e218ef8 // cmeq.16b v24, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e218ed8 // cmeq.16b v24, v22, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260307 // fmov w7, s24 + WORD $0x6e218eb8 // cmeq.16b v24, v21, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0x6e218e98 // cmeq.16b v24, v20, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031e // fmov w30, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0193 // orr x19, x12, x10 + WORD $0xd3607f8a // lsl x10, x28, #32 + WORD $0xb3503fca // bfi x10, x30, #48, #16 + WORD $0x53103cec // lsl w12, w7, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa11014a // orr x10, x10, x17 + WORD $0xb500044a // cbnz x10, LBB0_140 $136(%rip) + WORD $0xb50004f9 // cbnz x25, LBB0_141 $156(%rip) +LBB0_137: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000313 // cbnz x19, LBB0_142 $96(%rip) + WORD $0xb5009bca // cbnz x10, LBB0_395 $4984(%rip) + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff568 // b.hi LBB0_135 $-340(%rip) + WORD $0x1400026f // b LBB0_259 $2492(%rip) +LBB0_140: + WORD $0xb100077f // cmn x27, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c137b // csel x27, x27, x12, ne +LBB0_141: + WORD $0x8a39014c // bic x12, x10, x25 + WORD $0xaa0c072d // orr x13, x25, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a0273 // bic x19, x19, x10 + WORD $0x17ffffd0 // b LBB0_137 $-192(%rip) +LBB0_142: + WORD $0xdac0026c // rbit x12, x19 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x5400a323 // b.lo LBB0_418 $5220(%rip) + WORD $0x8b00018a // add x10, x12, x0 +LBB0_144: + WORD $0x91000540 // add x0, x10, #1 +LBB0_145: + WORD $0xb7f89680 // tbnz x0, #63, LBB0_389 $4816(%rip) + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb27ff7ea // mov x10, #9223372036854775806 + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x540098c8 // b.hi LBB0_400 $4888(%rip) + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x54ffa38d // b.le LBB0_1 $-2960(%rip) + WORD $0x140004a9 // b LBB0_388 $4772(%rip) +LBB0_148: + WORD $0xaa0001ec // orr x12, x15, x0 + WORD $0xb7f813ac // tbnz x12, #63, LBB0_178 $628(%rip) + WORD $0xeb0001ff // cmp x15, x0 + WORD $0x5400136b // b.lt LBB0_178 $620(%rip) + WORD $0xaa2f03f3 // mvn x19, x15 + WORD $0x17ffff75 // b LBB0_129 $-556(%rip) +LBB0_151: + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0001fa // subs x26, x15, x0 + WORD $0x372813c3 // tbnz w3, #5, LBB0_179 $632(%rip) + WORD $0x5400a020 // b.eq LBB0_417 $5124(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54006d23 // b.lo LBB0_321 $3492(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_155: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405554 // ldp q20, q21, [x10] + WORD $0xad415d56 // ldp q22, q23, [x10, #32] + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e208efb // cmeq.16b v27, v23, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x6e218ef7 // cmeq.16b v23, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x4e221f38 // and.16b v24, v25, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x4e221f58 // and.16b v24, v26, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x4e221f78 // and.16b v24, v27, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260285 // fmov w5, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260293 // fmov w19, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xd3607cec // lsl x12, x7, #32 + WORD $0xb3503e6c // bfi x12, x19, #48, #16 + WORD $0x53103cad // lsl w13, w5, #16 + WORD $0xaa0d018c // orr x12, x12, x13 + WORD $0xaa11018c // orr x12, x12, x17 + WORD $0xb500010c // cbnz x12, LBB0_159 $32(%rip) + WORD $0xb50001bb // cbnz x27, LBB0_160 $52(%rip) + WORD $0xb50002ea // cbnz x10, LBB0_161 $92(%rip) +LBB0_158: + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff8a8 // b.hi LBB0_155 $-236(%rip) + WORD $0x14000280 // b LBB0_290 $2560(%rip) +LBB0_159: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0018d // rbit x13, x12 + WORD $0xdac011ad // clz x13, x13 + WORD $0x8b0001ad // add x13, x13, x0 + WORD $0x9a8d1318 // csel x24, x24, x13, ne + WORD $0x9a8d1339 // csel x25, x25, x13, ne +LBB0_160: + WORD $0x8a3b018d // bic x13, x12, x27 + WORD $0xaa0d076e // orr x14, x27, x13, lsl #1 + WORD $0x8a2e018c // bic x12, x12, x14 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0d018c // adds x12, x12, x13 + WORD $0x1a9f37fb // cset w27, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0e018c // and x12, x12, x14 + WORD $0x8a2c014a // bic x10, x10, x12 + WORD $0xb4fffd6a // cbz x10, LBB0_158 $-84(%rip) +LBB0_161: + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x91000540 // add x0, x10, #1 + WORD $0xb6ffdfc0 // tbz x0, #63, LBB0_117 $-1032(%rip) + WORD $0x14000448 // b LBB0_389 $4384(%rip) +LBB0_162: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xeb00014f // subs x15, x10, x0 + WORD $0x54008ca0 // b.eq LBB0_401 $4500(%rip) + WORD $0x8b000127 // add x7, x9, x0 + WORD $0x394000ea // ldrb w10, [x7] + WORD $0x7100c15f // cmp w10, #48 + WORD $0x54001861 // b.ne LBB0_194 $780(%rip) + WORD $0xf10005ff // cmp x15, #1 + WORD $0x540016e1 // b.ne LBB0_192 $732(%rip) +LBB0_165: + WORD $0x5280003b // mov w27, #1 + WORD $0x140001b2 // b LBB0_251 $1736(%rip) +LBB0_166: + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x5400870c // b.gt LBB0_388 $4320(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x528000aa // mov w10, #5 + WORD $0x17fffca9 // b LBB0_2 $-3420(%rip) +LBB0_168: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xd100114c // sub x12, x10, #4 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x54008802 // b.hs LBB0_397 $4352(%rip) + WORD $0xb860692a // ldr w10, [x9, x0] + WORD $0x528d8c2c // mov w12, #27745 + WORD $0x72acae6c // movk w12, #25971, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x540089e1 // b.ne LBB0_403 $4412(%rip) + WORD $0x91001500 // add x0, x8, #5 + WORD $0x17fffedf // b LBB0_117 $-1156(%rip) +LBB0_171: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xd1000d4c // sub x12, x10, #3 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x540086a2 // b.hs LBB0_397 $4308(%rip) + WORD $0xb940030a // ldr w10, [x24] + WORD $0x528eadcc // mov w12, #30062 + WORD $0x72ad8d8c // movk w12, #27756, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x54000160 // b.eq LBB0_175 $44(%rip) + WORD $0x14000457 // b LBB0_408 $4444(%rip) +LBB0_173: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xd1000d4c // sub x12, x10, #3 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x54008562 // b.hs LBB0_397 $4268(%rip) + WORD $0xb940030a // ldr w10, [x24] + WORD $0x528e4e8c // mov w12, #29300 + WORD $0x72acaeac // movk w12, #25973, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x54008c41 // b.ne LBB0_412 $4488(%rip) +LBB0_175: + WORD $0x91001100 // add x0, x8, #4 + WORD $0x17fffeca // b LBB0_117 $-1240(%rip) +LBB0_176: + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x5400820c // b.gt LBB0_388 $4160(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x528000ca // mov w10, #6 + WORD $0x17fffc81 // b LBB0_2 $-3580(%rip) +LBB0_178: + WORD $0xd37ffd8c // lsr x12, x12, #63 + WORD $0x5200018c // eor w12, w12, #0x1 + WORD $0xd100040d // sub x13, x0, #1 + WORD $0xeb0d01ff // cmp x15, x13 + WORD $0x1a9f17ed // cset w13, eq + WORD $0x6a0d019f // tst w12, w13 + WORD $0xda800153 // csinv x19, x10, x0, eq + WORD $0x17fffed5 // b LBB0_129 $-1196(%rip) +LBB0_179: + WORD $0x54008c80 // b.eq LBB0_417 $4496(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54005a63 // b.lo LBB0_322 $2892(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x9280001b // mov x27, #-1 +LBB0_182: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x6e218ef8 // cmeq.16b v24, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e218ed8 // cmeq.16b v24, v22, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260305 // fmov w5, s24 + WORD $0x6e218eb8 // cmeq.16b v24, v21, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260307 // fmov w7, s24 + WORD $0x6e218e98 // cmeq.16b v24, v20, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0193 // orr x19, x12, x10 + WORD $0xd3607cea // lsl x10, x7, #32 + WORD $0xb3503f8a // bfi x10, x28, #48, #16 + WORD $0x53103cac // lsl w12, w5, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa11014a // orr x10, x10, x17 + WORD $0xb500044a // cbnz x10, LBB0_187 $136(%rip) + WORD $0xb50004f9 // cbnz x25, LBB0_188 $156(%rip) +LBB0_184: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000313 // cbnz x19, LBB0_189 $96(%rip) + WORD $0xb500770a // cbnz x10, LBB0_395 $3808(%rip) + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff568 // b.hi LBB0_182 $-340(%rip) + WORD $0x140001ed // b LBB0_295 $1972(%rip) +LBB0_187: + WORD $0xb100077f // cmn x27, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c137b // csel x27, x27, x12, ne +LBB0_188: + WORD $0x8a39014c // bic x12, x10, x25 + WORD $0xaa0c072d // orr x13, x25, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a0273 // bic x19, x19, x10 + WORD $0x17ffffd0 // b LBB0_184 $-192(%rip) +LBB0_189: + WORD $0xdac0026c // rbit x12, x19 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54007e63 // b.lo LBB0_418 $4044(%rip) + WORD $0x8b00018a // add x10, x12, x0 + WORD $0x91000540 // add x0, x10, #1 + WORD $0xb6ffc860 // tbz x0, #63, LBB0_117 $-1780(%rip) + WORD $0x1400038d // b LBB0_389 $3636(%rip) +LBB0_191: + WORD $0xaa0a03e7 // mov x7, x10 + WORD $0x92800013 // mov x19, #-1 + WORD $0xb5ffc92f // cbnz x15, LBB0_120 $-1756(%rip) + WORD $0x1400038f // b LBB0_392 $3644(%rip) +LBB0_192: + WORD $0x394004ea // ldrb w10, [x7, #1] + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x54ffe8e8 // b.hi LBB0_165 $-740(%rip) + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0x5280003b // mov w27, #1 + WORD $0xb20903ec // mov x12, #36028797027352576 + WORD $0xf280002c // movk x12, #1 + WORD $0xea0c015f // tst x10, x12 + WORD $0x54001e80 // b.eq LBB0_251 $976(%rip) +LBB0_194: + WORD $0xf10041ff // cmp x15, #16 + WORD $0x54004823 // b.lo LBB0_320 $2308(%rip) + WORD $0xd280001c // mov x28, #0 + WORD $0x9280001a // mov x26, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0x92800018 // mov x24, #-1 + WORD $0xaa0f03fb // mov x27, x15 +LBB0_196: + WORD $0x3cfc68f4 // ldr q20, [x7, x28] + WORD $0x6e258e95 // cmeq.16b v21, v20, v5 + WORD $0x6e268e96 // cmeq.16b v22, v20, v6 + WORD $0x6e278e97 // cmeq.16b v23, v20, v7 + WORD $0x4e308698 // add.16b v24, v20, v16 + WORD $0x6e383638 // cmhi.16b v24, v17, v24 + WORD $0x4e321e94 // and.16b v20, v20, v18 + WORD $0x6e338e94 // cmeq.16b v20, v20, v19 + WORD $0x4eb61ef6 // orr.16b v22, v23, v22 + WORD $0x4eb51e97 // orr.16b v23, v20, v21 + WORD $0x4eb61ef7 // orr.16b v23, v23, v22 + WORD $0x4eb81ef7 // orr.16b v23, v23, v24 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x2a2d03ed // mvn w13, w13 + WORD $0x32103dad // orr w13, w13, #0xffff0000 + WORD $0x5ac001ad // rbit w13, w13 + WORD $0x5ac011b3 // clz w19, w13 + WORD $0x1ad322ad // lsl w13, w21, w19 + WORD $0x0a2d0151 // bic w17, w10, w13 + WORD $0x0a2d019e // bic w30, w12, w13 + WORD $0x0a2d01c5 // bic w5, w14, w13 + WORD $0x7100427f // cmp w19, #16 + WORD $0x1a91014d // csel w13, w10, w17, eq + WORD $0x1a9e018c // csel w12, w12, w30, eq + WORD $0x1a8501ca // csel w10, w14, w5, eq + WORD $0x510005ae // sub w14, w13, #1 + WORD $0x6a0d01de // ands w30, w14, w13 + WORD $0x54002c81 // b.ne LBB0_287 $1424(%rip) + WORD $0x5100058e // sub w14, w12, #1 + WORD $0x6a0c01de // ands w30, w14, w12 + WORD $0x54002c21 // b.ne LBB0_287 $1412(%rip) + WORD $0x5100054e // sub w14, w10, #1 + WORD $0x6a0a01de // ands w30, w14, w10 + WORD $0x54002bc1 // b.ne LBB0_287 $1400(%rip) + WORD $0x340000cd // cbz w13, LBB0_202 $24(%rip) + WORD $0x5ac001ad // rbit w13, w13 + WORD $0x5ac011ad // clz w13, w13 + WORD $0xb100071f // cmn x24, #1 + WORD $0x54003801 // b.ne LBB0_302 $1792(%rip) + WORD $0x8b0d0398 // add x24, x28, x13 +LBB0_202: + WORD $0x340000cc // cbz w12, LBB0_205 $24(%rip) + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb100073f // cmn x25, #1 + WORD $0x540037a1 // b.ne LBB0_303 $1780(%rip) + WORD $0x8b0c0399 // add x25, x28, x12 +LBB0_205: + WORD $0x340000ca // cbz w10, LBB0_208 $24(%rip) + WORD $0x5ac0014a // rbit w10, w10 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb100075f // cmn x26, #1 + WORD $0x54003741 // b.ne LBB0_304 $1768(%rip) + WORD $0x8b0a039a // add x26, x28, x10 +LBB0_208: + WORD $0x7100427f // cmp w19, #16 + WORD $0x54000541 // b.ne LBB0_223 $168(%rip) + WORD $0xd100437b // sub x27, x27, #16 + WORD $0x9100439c // add x28, x28, #16 + WORD $0xf1003f7f // cmp x27, #15 + WORD $0x54fff708 // b.hi LBB0_196 $-288(%rip) + WORD $0x8b1c00f3 // add x19, x7, x28 + WORD $0xeb1c01ff // cmp x15, x28 + WORD $0x540004a0 // b.eq LBB0_224 $148(%rip) +LBB0_211: + WORD $0x8b1b026e // add x14, x19, x27 + WORD $0xf9401bea // ldr x10, [sp, #48] + WORD $0x8b13014a // add x10, x10, x19 + WORD $0xcb08015c // sub x28, x10, x8 + WORD $0xaa1303ef // mov x15, x19 + WORD $0x14000008 // b LBB0_215 $32(%rip) +LBB0_212: + WORD $0xb100075f // cmn x26, #1 + WORD $0x54002861 // b.ne LBB0_289 $1292(%rip) + WORD $0xd100079a // sub x26, x28, #1 +LBB0_214: + WORD $0x9100079c // add x28, x28, #1 + WORD $0xaa0f03f3 // mov x19, x15 + WORD $0xd100077b // sub x27, x27, #1 + WORD $0xb400133b // cbz x27, LBB0_253 $612(%rip) +LBB0_215: + WORD $0x38c015ea // ldrsb w10, [x15], #1 + WORD $0x5100c14c // sub w12, w10, #48 + WORD $0x7100299f // cmp w12, #10 + WORD $0x54ffff23 // b.lo LBB0_214 $-28(%rip) + WORD $0x5100ad4c // sub w12, w10, #43 + WORD $0x7100699f // cmp w12, #26 + WORD $0x54000128 // b.hi LBB0_220 $36(%rip) + WORD $0x10fffe4a // adr x10, LBB0_212 $-56(%rip) + WORD $0x386c6a8d // ldrb w13, [x20, x12] + WORD $0x8b0d094a // add x10, x10, x13, lsl #2 + WORD $0xd61f0140 // br x10 +LBB0_218: + WORD $0xb100071f // cmn x24, #1 + WORD $0x54002621 // b.ne LBB0_289 $1220(%rip) + WORD $0xd1000798 // sub x24, x28, #1 + WORD $0x17ffffee // b LBB0_214 $-72(%rip) +LBB0_220: + WORD $0x7101955f // cmp w10, #101 + WORD $0x540000e1 // b.ne LBB0_224 $28(%rip) +LBB0_221: + WORD $0xb100073f // cmn x25, #1 + WORD $0x54002561 // b.ne LBB0_289 $1196(%rip) + WORD $0xd1000799 // sub x25, x28, #1 + WORD $0x17ffffe8 // b LBB0_214 $-96(%rip) +LBB0_223: + WORD $0x8b3340ea // add x10, x7, w19, uxtw + WORD $0x8b1c0153 // add x19, x10, x28 +LBB0_224: + WORD $0x9280001b // mov x27, #-1 + WORD $0xb40064f8 // cbz x24, LBB0_402 $3228(%rip) +LBB0_225: + WORD $0xb40064da // cbz x26, LBB0_402 $3224(%rip) + WORD $0xb40064b9 // cbz x25, LBB0_402 $3220(%rip) + WORD $0xcb07026a // sub x10, x19, x7 + WORD $0xd100054c // sub x12, x10, #1 + WORD $0xeb0c031f // cmp x24, x12 + WORD $0x54000160 // b.eq LBB0_233 $44(%rip) + WORD $0xeb0c035f // cmp x26, x12 + WORD $0x54000120 // b.eq LBB0_233 $36(%rip) + WORD $0xeb0c033f // cmp x25, x12 + WORD $0x540000e0 // b.eq LBB0_233 $28(%rip) + WORD $0xf100074c // subs x12, x26, #1 + WORD $0x5400018b // b.lt LBB0_235 $48(%rip) + WORD $0xeb0c033f // cmp x25, x12 + WORD $0x54000140 // b.eq LBB0_235 $40(%rip) + WORD $0xaa3a03fb // mvn x27, x26 + WORD $0x1400006a // b LBB0_250 $424(%rip) +LBB0_233: + WORD $0xcb0a03fb // neg x27, x10 + WORD $0x14000068 // b LBB0_250 $416(%rip) +LBB0_234: + WORD $0x5ac001aa // rbit w10, w13 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3b03ec // mvn x12, x27 + WORD $0xcb0a0193 // sub x19, x12, x10 + WORD $0x17fffdbf // b LBB0_129 $-2308(%rip) +LBB0_235: + WORD $0xaa19030c // orr x12, x24, x25 + WORD $0xb7f80b4c // tbnz x12, #63, LBB0_249 $360(%rip) + WORD $0xeb19031f // cmp x24, x25 + WORD $0x54000b0b // b.lt LBB0_249 $352(%rip) + WORD $0xaa3803fb // mvn x27, x24 + WORD $0x1400005d // b LBB0_250 $372(%rip) +LBB0_238: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54003a63 // b.lo LBB0_326 $1868(%rip) +LBB0_239: + WORD $0xad405414 // ldp q20, q21, [x0] + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e208eb7 // cmeq.16b v23, v21, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c7 // fmov w7, s22 + WORD $0x4e221ef6 // and.16b v22, v23, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x33103d87 // bfi w7, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350034aa // cbnz w10, LBB0_323 $1684(%rip) + WORD $0xb500357b // cbnz x27, LBB0_324 $1708(%rip) + WORD $0xb40036e7 // cbz x7, LBB0_325 $1756(%rip) +LBB0_242: + WORD $0xdac000ea // rbit x10, x7 + WORD $0xdac0114a // clz x10, x10 + WORD $0xf94017ec // ldr x12, [sp, #40] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a0180 // add x0, x12, x10 + WORD $0x17fffd7a // b LBB0_116 $-2584(%rip) +LBB0_243: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54001383 // b.lo LBB0_268 $624(%rip) +LBB0_244: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602da // fmov w26, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e218eb6 // cmeq.16b v22, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e218e96 // cmeq.16b v22, v20, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cd // fmov w13, s22 + WORD $0x33103d9a // bfi w26, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350037aa // cbnz w10, LBB0_338 $1780(%rip) + WORD $0xb5003859 // cbnz x25, LBB0_339 $1800(%rip) +LBB0_246: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb4000e5a // cbz x26, LBB0_266 $456(%rip) + WORD $0xdac0034c // rbit x12, x26 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54005fa3 // b.lo LBB0_419 $3060(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0x17fffd48 // b LBB0_116 $-2784(%rip) +LBB0_249: + WORD $0xd37ffd8c // lsr x12, x12, #63 + WORD $0x5200018c // eor w12, w12, #0x1 + WORD $0xd100072d // sub x13, x25, #1 + WORD $0xeb0d031f // cmp x24, x13 + WORD $0x1a9f17ed // cset w13, eq + WORD $0x6a0d019f // tst w12, w13 + WORD $0xda99015b // csinv x27, x10, x25, eq +LBB0_250: + WORD $0xb7f855bb // tbnz x27, #63, LBB0_402 $2740(%rip) +LBB0_251: + WORD $0x8b000360 // add x0, x27, x0 + WORD $0x17fffd3f // b LBB0_117 $-2820(%rip) +LBB0_252: + WORD $0xaa3b03ea // mvn x10, x27 + WORD $0xcb2c4153 // sub x19, x10, w12, uxtw + WORD $0x17fffd57 // b LBB0_129 $-2724(%rip) +LBB0_253: + WORD $0xaa0e03f3 // mov x19, x14 + WORD $0x9280001b // mov x27, #-1 + WORD $0xb5ffeff8 // cbnz x24, LBB0_225 $-516(%rip) + WORD $0x140002a4 // b LBB0_402 $2704(%rip) +LBB0_254: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54003763 // b.lo LBB0_343 $1772(%rip) +LBB0_255: + WORD $0xad405414 // ldp q20, q21, [x0] + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e208eb7 // cmeq.16b v23, v21, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c7 // fmov w7, s22 + WORD $0x4e221ef6 // and.16b v22, v23, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x33103d87 // bfi w7, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350031aa // cbnz w10, LBB0_340 $1588(%rip) + WORD $0xb500327b // cbnz x27, LBB0_341 $1612(%rip) + WORD $0xb40033e7 // cbz x7, LBB0_342 $1660(%rip) +LBB0_258: + WORD $0xdac000ea // rbit x10, x7 + WORD $0xdac0114a // clz x10, x10 + WORD $0xf94017ec // ldr x12, [sp, #40] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a0180 // add x0, x12, x10 + WORD $0x17fffdac // b LBB0_145 $-2384(%rip) +LBB0_259: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54000b03 // b.lo LBB0_279 $352(%rip) +LBB0_260: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602da // fmov w26, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e218eb6 // cmeq.16b v22, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e218e96 // cmeq.16b v22, v20, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cd // fmov w13, s22 + WORD $0x33103d9a // bfi w26, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350034aa // cbnz w10, LBB0_355 $1684(%rip) + WORD $0xb5003559 // cbnz x25, LBB0_356 $1704(%rip) +LBB0_262: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb40005da // cbz x26, LBB0_277 $184(%rip) + WORD $0xdac0034c // rbit x12, x26 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x540052e3 // b.lo LBB0_419 $2652(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0x17fffd7a // b LBB0_145 $-2584(%rip) +LBB0_265: + WORD $0xaa3b03ec // mvn x12, x27 + WORD $0xcb2a4193 // sub x19, x12, w10, uxtw + WORD $0x17fffcfb // b LBB0_129 $-3092(%rip) +LBB0_266: + WORD $0x350051ec // cbnz w12, LBB0_419 $2620(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_268: + WORD $0xb5003499 // cbnz x25, LBB0_359 $1680(%rip) + WORD $0xb400451a // cbz x26, LBB0_390 $2208(%rip) +LBB0_270: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x54000300 // b.eq LBB0_276 $96(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_274 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54005109 // b.ls LBB0_420 $2592(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffea1 // b.ne LBB0_270 $-44(%rip) + WORD $0x1400021b // b LBB0_390 $2156(%rip) +LBB0_274: + WORD $0xf100075f // cmp x26, #1 + WORD $0x54004320 // b.eq LBB0_390 $2148(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8a1318 // csel x24, x24, x10, ne + WORD $0x5280004a // mov w10, #2 + WORD $0x9a8a114c // csel x12, x10, x10, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffd01 // b.ne LBB0_270 $-96(%rip) + WORD $0x1400020e // b LBB0_390 $2104(%rip) +LBB0_276: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0x17fffcbd // b LBB0_116 $-3340(%rip) +LBB0_277: + WORD $0x35004dac // cbnz w12, LBB0_419 $2484(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_279: + WORD $0xb50032b9 // cbnz x25, LBB0_363 $1620(%rip) + WORD $0xb40040da // cbz x26, LBB0_390 $2072(%rip) +LBB0_281: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x540003a0 // b.eq LBB0_288 $116(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_285 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54004cc9 // b.ls LBB0_420 $2456(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffea1 // b.ne LBB0_281 $-44(%rip) + WORD $0x140001f9 // b LBB0_390 $2020(%rip) +LBB0_285: + WORD $0xf100075f // cmp x26, #1 + WORD $0x54003ee0 // b.eq LBB0_390 $2012(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8a1318 // csel x24, x24, x10, ne + WORD $0x5280004a // mov w10, #2 + WORD $0x9a8a114c // csel x12, x10, x10, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffd01 // b.ne LBB0_281 $-96(%rip) + WORD $0x140001ec // b LBB0_390 $1968(%rip) +LBB0_287: + WORD $0x5ac003ca // rbit w10, w30 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3c03ec // mvn x12, x28 + WORD $0xcb0a019b // sub x27, x12, x10 + WORD $0x17ffff59 // b LBB0_250 $-668(%rip) +LBB0_288: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0x17fffd2e // b LBB0_145 $-2888(%rip) +LBB0_289: + WORD $0xcb1c03fb // neg x27, x28 + WORD $0x17ffff54 // b LBB0_250 $-688(%rip) +LBB0_290: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54003183 // b.lo LBB0_368 $1584(%rip) +LBB0_291: + WORD $0xad405414 // ldp q20, q21, [x0] + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e208eb7 // cmeq.16b v23, v21, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c7 // fmov w7, s22 + WORD $0x4e221ef6 // and.16b v22, v23, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x33103d87 // bfi w7, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x35002bca // cbnz w10, LBB0_365 $1400(%rip) + WORD $0xb5002c9b // cbnz x27, LBB0_366 $1424(%rip) + WORD $0xb4002e07 // cbz x7, LBB0_367 $1472(%rip) +LBB0_294: + WORD $0xdac000ea // rbit x10, x7 + WORD $0xdac0114a // clz x10, x10 + WORD $0xf94017ec // ldr x12, [sp, #40] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a0180 // add x0, x12, x10 + WORD $0xb6ff8e40 // tbz x0, #63, LBB0_117 $-3640(%rip) + WORD $0x140001bc // b LBB0_389 $1776(%rip) +LBB0_295: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54000863 // b.lo LBB0_307 $268(%rip) +LBB0_296: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602da // fmov w26, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e218eb6 // cmeq.16b v22, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e218e96 // cmeq.16b v22, v20, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cd // fmov w13, s22 + WORD $0x33103d9a // bfi w26, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x35002eca // cbnz w10, LBB0_380 $1496(%rip) + WORD $0xb5002f79 // cbnz x25, LBB0_381 $1516(%rip) +LBB0_298: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb400033a // cbz x26, LBB0_305 $100(%rip) + WORD $0xdac0034c // rbit x12, x26 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54003e63 // b.lo LBB0_419 $1996(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0xb6ff87e0 // tbz x0, #63, LBB0_117 $-3844(%rip) + WORD $0x14000189 // b LBB0_389 $1572(%rip) +LBB0_301: + WORD $0x9280000f // mov x15, #-1 + WORD $0xaa1803e7 // mov x7, x24 + WORD $0xaa1303fa // mov x26, x19 + WORD $0x92800000 // mov x0, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0x17fffb30 // b LBB0_78 $-4928(%rip) +LBB0_302: + WORD $0xaa3c03ea // mvn x10, x28 + WORD $0xcb2d415b // sub x27, x10, w13, uxtw + WORD $0x17fffef4 // b LBB0_250 $-1072(%rip) +LBB0_303: + WORD $0xaa3c03ea // mvn x10, x28 + WORD $0xcb2c415b // sub x27, x10, w12, uxtw + WORD $0x17fffef1 // b LBB0_250 $-1084(%rip) +LBB0_304: + WORD $0xaa3c03ec // mvn x12, x28 + WORD $0xcb2a419b // sub x27, x12, w10, uxtw + WORD $0x17fffeee // b LBB0_250 $-1096(%rip) +LBB0_305: + WORD $0x35003bcc // cbnz w12, LBB0_419 $1912(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_307: + WORD $0xb5002bd9 // cbnz x25, LBB0_382 $1400(%rip) + WORD $0xb4002efa // cbz x26, LBB0_390 $1500(%rip) +LBB0_309: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x540004a0 // b.eq LBB0_317 $148(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_313 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54003ae9 // b.ls LBB0_420 $1884(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffea1 // b.ne LBB0_309 $-44(%rip) + WORD $0x1400016a // b LBB0_390 $1448(%rip) +LBB0_313: + WORD $0xf100075f // cmp x26, #1 + WORD $0x54002d00 // b.eq LBB0_390 $1440(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8a1318 // csel x24, x24, x10, ne + WORD $0x5280004a // mov w10, #2 + WORD $0x9a8a114c // csel x12, x10, x10, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffd01 // b.ne LBB0_309 $-96(%rip) + WORD $0x1400015d // b LBB0_390 $1396(%rip) +LBB0_315: + WORD $0xd280001b // mov x27, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffce02 // b.hs LBB0_239 $-1600(%rip) + WORD $0x14000041 // b LBB0_326 $260(%rip) +LBB0_316: + WORD $0xd2800019 // mov x25, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffd1a2 // b.hs LBB0_244 $-1484(%rip) + WORD $0x17ffff27 // b LBB0_268 $-868(%rip) +LBB0_317: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0xb6ff8000 // tbz x0, #63, LBB0_117 $-4096(%rip) + WORD $0x1400014a // b LBB0_389 $1320(%rip) +LBB0_318: + WORD $0xd280001b // mov x27, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffd8a2 // b.hs LBB0_255 $-1260(%rip) + WORD $0x1400007e // b LBB0_343 $504(%rip) +LBB0_319: + WORD $0xd2800019 // mov x25, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffdc42 // b.hs LBB0_260 $-1144(%rip) + WORD $0x17ffff38 // b LBB0_279 $-800(%rip) +LBB0_320: + WORD $0x92800018 // mov x24, #-1 + WORD $0xaa0703f3 // mov x19, x7 + WORD $0xaa0f03fb // mov x27, x15 + WORD $0x92800019 // mov x25, #-1 + WORD $0x9280001a // mov x26, #-1 + WORD $0x17fffe0c // b LBB0_211 $-2000(%rip) +LBB0_321: + WORD $0xd280001b // mov x27, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffeaa2 // b.hs LBB0_291 $-684(%rip) + WORD $0x140000df // b LBB0_368 $892(%rip) +LBB0_322: + WORD $0xd2800019 // mov x25, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffee62 // b.hs LBB0_296 $-564(%rip) + WORD $0x17ffffb4 // b LBB0_307 $-304(%rip) +LBB0_323: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0d018c // add x12, x12, x13 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_324: + WORD $0x0a3b014c // bic w12, w10, w27 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f799b // bfi w27, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a1b014a // and w10, w10, w27 + WORD $0x1a9f37fb // cset w27, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a070147 // and x7, x10, x7 + WORD $0xb5ffc967 // cbnz x7, LBB0_242 $-1748(%rip) +LBB0_325: + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_326: + WORD $0xb50010db // cbnz x27, LBB0_357 $536(%rip) + WORD $0xb40003da // cbz x26, LBB0_335 $120(%rip) +LBB0_328: + WORD $0xd280000a // mov x10, #0 +LBB0_329: + WORD $0x386a680c // ldrb w12, [x0, x10] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_334 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_332 $20(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xeb0a035f // cmp x26, x10 + WORD $0x54ffff21 // b.ne LBB0_329 $-28(%rip) + WORD $0x14000016 // b LBB0_336 $88(%rip) +LBB0_332: + WORD $0xd100074c // sub x12, x26, #1 + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x540020e0 // b.eq LBB0_390 $1052(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a018c // add x12, x12, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980198 // csel x24, x12, x24, eq + WORD $0x9a990199 // csel x25, x12, x25, eq + WORD $0x8b0a000c // add x12, x0, x10 + WORD $0x91000980 // add x0, x12, #2 + WORD $0xcb0a034c // sub x12, x26, x10 + WORD $0xd1000b4d // sub x13, x26, #2 + WORD $0xd100099a // sub x26, x12, #2 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54fffce1 // b.ne LBB0_328 $-100(%rip) + WORD $0x140000f9 // b LBB0_390 $996(%rip) +LBB0_334: + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0x91000540 // add x0, x10, #1 +LBB0_335: + WORD $0xcb090000 // sub x0, x0, x9 + WORD $0x17fffba7 // b LBB0_116 $-4452(%rip) +LBB0_336: + WORD $0x7100899f // cmp w12, #34 + WORD $0x54001e61 // b.ne LBB0_390 $972(%rip) + WORD $0x8b1a0000 // add x0, x0, x26 + WORD $0x17fffffb // b LBB0_335 $-20(%rip) +LBB0_338: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne +LBB0_339: + WORD $0x0a39014c // bic w12, w10, w25 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f7999 // bfi w25, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a19014a // and w10, w10, w25 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a1a015a // and x26, x10, x26 + WORD $0x17fffe33 // b LBB0_246 $-1844(%rip) +LBB0_340: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0d018c // add x12, x12, x13 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_341: + WORD $0x0a3b014c // bic w12, w10, w27 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f799b // bfi w27, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a1b014a // and w10, w10, w27 + WORD $0x1a9f37fb // cset w27, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a070147 // and x7, x10, x7 + WORD $0xb5ffcc67 // cbnz x7, LBB0_258 $-1652(%rip) +LBB0_342: + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_343: + WORD $0xb500097b // cbnz x27, LBB0_361 $300(%rip) + WORD $0xb40003da // cbz x26, LBB0_352 $120(%rip) +LBB0_345: + WORD $0xd280000a // mov x10, #0 +LBB0_346: + WORD $0x386a680c // ldrb w12, [x0, x10] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_351 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_349 $20(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xeb0a035f // cmp x26, x10 + WORD $0x54ffff21 // b.ne LBB0_346 $-28(%rip) + WORD $0x14000016 // b LBB0_353 $88(%rip) +LBB0_349: + WORD $0xd100074c // sub x12, x26, #1 + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x54001720 // b.eq LBB0_390 $740(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a018c // add x12, x12, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980198 // csel x24, x12, x24, eq + WORD $0x9a990199 // csel x25, x12, x25, eq + WORD $0x8b0a000c // add x12, x0, x10 + WORD $0x91000980 // add x0, x12, #2 + WORD $0xcb0a034c // sub x12, x26, x10 + WORD $0xd1000b4d // sub x13, x26, #2 + WORD $0xd100099a // sub x26, x12, #2 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54fffce1 // b.ne LBB0_345 $-100(%rip) + WORD $0x140000ab // b LBB0_390 $684(%rip) +LBB0_351: + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0x91000540 // add x0, x10, #1 +LBB0_352: + WORD $0xcb090000 // sub x0, x0, x9 + WORD $0x17fffbf1 // b LBB0_145 $-4156(%rip) +LBB0_353: + WORD $0x7100899f // cmp w12, #34 + WORD $0x540014a1 // b.ne LBB0_390 $660(%rip) + WORD $0x8b1a0000 // add x0, x0, x26 + WORD $0x17fffffb // b LBB0_352 $-20(%rip) +LBB0_355: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne +LBB0_356: + WORD $0x0a39014c // bic w12, w10, w25 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f7999 // bfi w25, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a19014a // and w10, w10, w25 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a1a015a // and x26, x10, x26 + WORD $0x17fffe4b // b LBB0_262 $-1748(%rip) +LBB0_357: + WORD $0xb40011fa // cbz x26, LBB0_390 $572(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x9a990159 // csel x25, x10, x25, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffee9a // cbnz x26, LBB0_328 $-560(%rip) + WORD $0x17ffff90 // b LBB0_335 $-448(%rip) +LBB0_359: + WORD $0xb40010ba // cbz x26, LBB0_390 $532(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffcafa // cbnz x26, LBB0_270 $-1700(%rip) + WORD $0x1400007d // b LBB0_390 $500(%rip) +LBB0_361: + WORD $0xb4000f9a // cbz x26, LBB0_390 $496(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x9a990159 // csel x25, x10, x25, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5fff5fa // cbnz x26, LBB0_345 $-324(%rip) + WORD $0x17ffffcb // b LBB0_352 $-212(%rip) +LBB0_363: + WORD $0xb4000e5a // cbz x26, LBB0_390 $456(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffccda // cbnz x26, LBB0_281 $-1640(%rip) + WORD $0x1400006a // b LBB0_390 $424(%rip) +LBB0_365: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0d018c // add x12, x12, x13 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_366: + WORD $0x0a3b014c // bic w12, w10, w27 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f799b // bfi w27, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a1b014a // and w10, w10, w27 + WORD $0x1a9f37fb // cset w27, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a070147 // and x7, x10, x7 + WORD $0xb5ffd247 // cbnz x7, LBB0_294 $-1464(%rip) +LBB0_367: + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_368: + WORD $0xb500085b // cbnz x27, LBB0_384 $264(%rip) + WORD $0xb40003da // cbz x26, LBB0_377 $120(%rip) +LBB0_370: + WORD $0xd280000a // mov x10, #0 +LBB0_371: + WORD $0x386a680c // ldrb w12, [x0, x10] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_376 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_374 $20(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xeb0a035f // cmp x26, x10 + WORD $0x54ffff21 // b.ne LBB0_371 $-28(%rip) + WORD $0x14000017 // b LBB0_378 $92(%rip) +LBB0_374: + WORD $0xd100074c // sub x12, x26, #1 + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x540008a0 // b.eq LBB0_390 $276(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a018c // add x12, x12, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980198 // csel x24, x12, x24, eq + WORD $0x9a990199 // csel x25, x12, x25, eq + WORD $0x8b0a000c // add x12, x0, x10 + WORD $0x91000980 // add x0, x12, #2 + WORD $0xcb0a034c // sub x12, x26, x10 + WORD $0xd1000b4d // sub x13, x26, #2 + WORD $0xd100099a // sub x26, x12, #2 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54fffce1 // b.ne LBB0_370 $-100(%rip) + WORD $0x14000037 // b LBB0_390 $220(%rip) +LBB0_376: + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0x91000540 // add x0, x10, #1 +LBB0_377: + WORD $0xcb090000 // sub x0, x0, x9 + WORD $0xb6ff5cc0 // tbz x0, #63, LBB0_117 $-5224(%rip) + WORD $0x14000030 // b LBB0_389 $192(%rip) +LBB0_378: + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000601 // b.ne LBB0_390 $192(%rip) + WORD $0x8b1a0000 // add x0, x0, x26 + WORD $0x17fffffa // b LBB0_377 $-24(%rip) +LBB0_380: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne +LBB0_381: + WORD $0x0a39014c // bic w12, w10, w25 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f7999 // bfi w25, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a19014a // and w10, w10, w25 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a1a015a // and x26, x10, x26 + WORD $0x17fffe7a // b LBB0_298 $-1560(%rip) +LBB0_382: + WORD $0xb400035a // cbz x26, LBB0_390 $104(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffd3ba // cbnz x26, LBB0_309 $-1420(%rip) + WORD $0x14000012 // b LBB0_390 $72(%rip) +LBB0_384: + WORD $0xb400023a // cbz x26, LBB0_390 $68(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x9a990159 // csel x25, x10, x25, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5fff71a // cbnz x26, LBB0_370 $-288(%rip) + WORD $0x17ffffd4 // b LBB0_377 $-176(%rip) +LBB0_386: + WORD $0xf9000028 // str x8, [x1] +LBB0_387: + WORD $0x9280000f // mov x15, #-1 + WORD $0x1400001a // b LBB0_400 $104(%rip) +LBB0_388: + WORD $0x928000cf // mov x15, #-7 + WORD $0x14000018 // b LBB0_400 $96(%rip) +LBB0_389: + WORD $0xb100041f // cmn x0, #1 + WORD $0x54000281 // b.ne LBB0_399 $80(%rip) +LBB0_390: + WORD $0x92800000 // mov x0, #-1 + WORD $0xaa0f03f8 // mov x24, x15 + WORD $0x14000011 // b LBB0_399 $68(%rip) +LBB0_391: + WORD $0x92800013 // mov x19, #-1 +LBB0_392: + WORD $0xaa3303e9 // mvn x9, x19 + WORD $0x8b090108 // add x8, x8, x9 +LBB0_393: + WORD $0xf9000028 // str x8, [x1] +LBB0_394: + WORD $0x9280002f // mov x15, #-2 + WORD $0x1400000d // b LBB0_400 $52(%rip) +LBB0_395: + WORD $0xb100071f // cmn x24, #1 + WORD $0x540000a0 // b.eq LBB0_398 $20(%rip) + WORD $0x92800020 // mov x0, #-2 + WORD $0x14000007 // b LBB0_399 $28(%rip) +LBB0_397: + WORD $0xf900002a // str x10, [x1] + WORD $0x17ffffec // b LBB0_387 $-80(%rip) +LBB0_398: + WORD $0xdac00148 // rbit x8, x10 + WORD $0xdac01108 // clz x8, x8 + WORD $0x8b000118 // add x24, x8, x0 + WORD $0x92800020 // mov x0, #-2 +LBB0_399: + WORD $0xf9000038 // str x24, [x1] + WORD $0xaa0003ef // mov x15, x0 +LBB0_400: + WORD $0xaa0f03e0 // mov x0, x15 + WORD $0xa9497bfd // ldp x29, x30, [sp, #144] + WORD $0xa9484ff4 // ldp x20, x19, [sp, #128] + WORD $0xa94757f6 // ldp x22, x21, [sp, #112] + WORD $0xa9465ff8 // ldp x24, x23, [sp, #96] + WORD $0xa94567fa // ldp x26, x25, [sp, #80] + WORD $0xa9446ffc // ldp x28, x27, [sp, #64] + WORD $0x910283ff // add sp, sp, #160 + WORD $0xd65f03c0 // ret +LBB0_401: + WORD $0x9280001b // mov x27, #-1 +LBB0_402: + WORD $0xcb1b0108 // sub x8, x8, x27 + WORD $0x17ffffe6 // b LBB0_393 $-104(%rip) +LBB0_403: + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x7101855f // cmp w10, #97 + WORD $0x54fffc81 // b.ne LBB0_394 $-112(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101b15f // cmp w10, #108 + WORD $0x54fffbe1 // b.ne LBB0_394 $-132(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101cd5f // cmp w10, #115 + WORD $0x54fffb41 // b.ne LBB0_394 $-152(%rip) + WORD $0x9100110a // add x10, x8, #4 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101953f // cmp w9, #101 + WORD $0x54fffaa1 // b.ne LBB0_394 $-172(%rip) + WORD $0x91001508 // add x8, x8, #5 + WORD $0x17ffffd2 // b LBB0_393 $-184(%rip) +LBB0_408: + WORD $0xf9000028 // str x8, [x1] + WORD $0x3940030a // ldrb w10, [x24] + WORD $0x7101b95f // cmp w10, #110 + WORD $0x54fff9e1 // b.ne LBB0_394 $-196(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101d55f // cmp w10, #117 + WORD $0x54fff941 // b.ne LBB0_394 $-216(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101b15f // cmp w10, #108 + WORD $0x54fff8a1 // b.ne LBB0_394 $-236(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101b13f // cmp w9, #108 + WORD $0x54fff801 // b.ne LBB0_394 $-256(%rip) + WORD $0x14000014 // b LBB0_416 $80(%rip) +LBB0_412: + WORD $0xf9000028 // str x8, [x1] + WORD $0x3940030a // ldrb w10, [x24] + WORD $0x7101d15f // cmp w10, #116 + WORD $0x54fff761 // b.ne LBB0_394 $-276(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101c95f // cmp w10, #114 + WORD $0x54fff6c1 // b.ne LBB0_394 $-296(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101d55f // cmp w10, #117 + WORD $0x54fff621 // b.ne LBB0_394 $-316(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101953f // cmp w9, #101 + WORD $0x54fff581 // b.ne LBB0_394 $-336(%rip) +LBB0_416: + WORD $0x91001108 // add x8, x8, #4 + WORD $0x17ffffa9 // b LBB0_393 $-348(%rip) +LBB0_417: + WORD $0xaa0003ef // mov x15, x0 + WORD $0x17ffffa1 // b LBB0_390 $-380(%rip) +LBB0_418: + WORD $0x8b000158 // add x24, x10, x0 + WORD $0x92800020 // mov x0, #-2 + WORD $0x17ffffb1 // b LBB0_399 $-316(%rip) +LBB0_419: + WORD $0xcb090008 // sub x8, x0, x9 + WORD $0x8b0a0118 // add x24, x8, x10 + WORD $0x92800020 // mov x0, #-2 + WORD $0x17ffffad // b LBB0_399 $-332(%rip) +LBB0_420: + WORD $0xcb090018 // sub x24, x0, x9 + WORD $0x92800020 // mov x0, #-2 + WORD $0x17ffffaa // b LBB0_399 $-344(%rip) + // .p2align 1, 0x00 +LJTI0_0: + WORD $0x00050000 + WORD $0x006d000e + WORD $0x01070071 + // // .word (LBB0_32-LBB0_32)>>2 +// .word (LBB0_34-LBB0_32)>>2 +// .word (LBB0_37-LBB0_32)>>2 +// .word (LBB0_49-LBB0_32)>>2 +// .word (LBB0_51-LBB0_32)>>2 +// .word (LBB0_87-LBB0_32)>>2 + +LJTI0_1: + WORD $0x06c006ce + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c00213 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x027006c0 + WORD $0x06c006c0 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x027b06c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c00283 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c0028e + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c00298 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x02a306c0 + // // .word (LBB0_400-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_151-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_162-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_166-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_168-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_171-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_173-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_176-LBB0_56)>>2 + +LJTI0_2: + WORD $0x12001e00 + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x00181e1e + // // .byte (LBB0_212-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_212-LBB0_212)>>2 +// .byte (LBB0_218-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_221-LBB0_212)>>2 + +LJTI0_3: + WORD $0x01070013 + WORD $0x00170013 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x00000000 + // // .word (LBB0_85-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_85-LBB0_80)>>2 +// .word (LBB0_86-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_80-LBB0_80)>>2 + +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__skip_object(SB), $0-40 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $192, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_skip_object: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + MOVD m+16(FP), R2 + MOVD flags+24(FP), R3 + CALL ·__skip_object_arm64_entry__+76(SB) // _skip_object + MOVD R0, ret+32(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/skip_object_subr_arm64.go b/internal/native/neon/skip_object_subr_arm64.go new file mode 100644 index 000000000..2ba640469 --- /dev/null +++ b/internal/native/neon/skip_object_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __skip_object_arm64_entry__() uintptr + +var ( + _subr__skip_object uintptr = __skip_object_arm64_entry__() + 64 +) + +const ( + _stack__skip_object = 160 +) + +var ( + _ = _subr__skip_object +) + +const ( + _ = _stack__skip_object +) diff --git a/internal/native/neon/skip_one_arm64.go b/internal/native/neon/skip_one_arm64.go new file mode 100644 index 000000000..cd4b64a28 --- /dev/null +++ b/internal/native/neon/skip_one_arm64.go @@ -0,0 +1,37 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + // `unsafe` + + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) + +//go:nosplit +func skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) { + return __skip_one(s, p, m, flags) +} diff --git a/internal/native/neon/skip_one_arm64.s b/internal/native/neon/skip_one_arm64.s new file mode 100644 index 000000000..9b39f7fb5 --- /dev/null +++ b/internal/native/neon/skip_one_arm64.s @@ -0,0 +1,2702 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__skip_one_arm64_entry__(SB), NOSPLIT, $144 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910283ff // add sp, sp, #160 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x00000001; WORD $0x00000000 // .quad 1 + WORD $0x00000000; WORD $0x00000000 // .quad 0 +lCPI0_1: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_2: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_skip_one: + MOVD.W R30, -160(RSP) // WORD $0xf8160ffe // str x30, [sp, #-160]! + WORD $0xa9046ffc // stp x28, x27, [sp, #64] + WORD $0xa90567fa // stp x26, x25, [sp, #80] + WORD $0xa9065ff8 // stp x24, x23, [sp, #96] + WORD $0xa90757f6 // stp x22, x21, [sp, #112] + WORD $0xa9084ff4 // stp x20, x19, [sp, #128] + WORD $0xa9097bfd // stp x29, x30, [sp, #144] + WORD $0xaa0003e6 // mov x6, x0 +Lloh0: + WORD $0x10fffd88 // adr x8, lCPI0_0 $-80(%rip) +Lloh1: + WORD $0x3dc00100 // ldr q0, [x8, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x3d800040 // str q0, [x2] + WORD $0xf9400009 // ldr x9, [x0] + WORD $0xaa2903e8 // mvn x8, x9 + WORD $0xf90013e8 // str x8, [sp, #32] + WORD $0x5280002b // mov w11, #1 + WORD $0xcb090168 // sub x8, x11, x9 + WORD $0xf90017e8 // str x8, [sp, #40] + WORD $0xf9400020 // ldr x0, [x1] + WORD $0xcb0903e8 // neg x8, x9 + WORD $0xf9001be8 // str x8, [sp, #48] + WORD $0xd1000528 // sub x8, x9, #1 + WORD $0xf9001fe8 // str x8, [sp, #56] + WORD $0x92800017 // mov x23, #-1 + WORD $0xd284c010 // mov x16, #9728 + WORD $0xf2c00030 // movk x16, #1, lsl #32 + WORD $0x4f01e440 // movi.16b v0, #34 + WORD $0x4f02e781 // movi.16b v1, #92 +Lloh2: + WORD $0x10fffba8 // adr x8, lCPI0_1 $-140(%rip) +Lloh3: + WORD $0x3dc00102 // ldr q2, [x8, lCPI0_1@PAGEOFF] $0(%rip) +Lloh4: + WORD $0x10fffbe8 // adr x8, lCPI0_2 $-132(%rip) +Lloh5: + WORD $0x3dc00103 // ldr q3, [x8, lCPI0_2@PAGEOFF] $0(%rip) + WORD $0x4f01e404 // movi.16b v4, #32 + WORD $0x4f01e5c5 // movi.16b v5, #46 + WORD $0x4f01e566 // movi.16b v6, #43 +Lloh6: + WORD $0x10010974 // adr x20, LJTI0_2 $8492(%rip) +Lloh7: + WORD $0x91000294 // add x20, x20, LJTI0_2@PAGEOFF $0(%rip) + WORD $0x12800015 // mov w21, #-1 + WORD $0x4f01e5a7 // movi.16b v7, #45 + WORD $0x4f06e610 // movi.16b v16, #208 +Lloh8: + WORD $0x100109b6 // adr x22, LJTI0_3 $8500(%rip) +Lloh9: + WORD $0x910002d6 // add x22, x22, LJTI0_3@PAGEOFF $0(%rip) + WORD $0x4f00e551 // movi.16b v17, #10 + WORD $0x4f06e7f2 // movi.16b v18, #223 + WORD $0x4f02e4b3 // movi.16b v19, #69 + WORD $0x52800039 // mov w25, #1 +Lloh10: + WORD $0x1000ffe4 // adr x4, LJTI0_0 $8188(%rip) +Lloh11: + WORD $0x91000084 // add x4, x4, LJTI0_0@PAGEOFF $0(%rip) + WORD $0x14000009 // b LBB0_4 $36(%rip) +LBB0_1: + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x5280008a // mov w10, #4 +LBB0_2: + WORD $0xf900050a // str x10, [x8, #8] +LBB0_3: + WORD $0xf9400059 // ldr x25, [x2] + WORD $0xaa1703ef // mov x15, x23 + WORD $0xb400f419 // cbz x25, LBB0_400 $7808(%rip) +LBB0_4: + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0f001f // cmp x0, x15 + WORD $0x54000162 // b.hs LBB0_9 $44(%rip) + WORD $0x38606928 // ldrb w8, [x9, x0] + WORD $0x7100351f // cmp w8, #13 + WORD $0x54000100 // b.eq LBB0_9 $32(%rip) + WORD $0x7100811f // cmp w8, #32 + WORD $0x540000c0 // b.eq LBB0_9 $24(%rip) + WORD $0x51002d08 // sub w8, w8, #11 + WORD $0x3100091f // cmn w8, #2 + WORD $0x54000062 // b.hs LBB0_9 $12(%rip) + WORD $0xaa0003e8 // mov x8, x0 + WORD $0x14000035 // b LBB0_29 $212(%rip) +LBB0_9: + WORD $0x91000408 // add x8, x0, #1 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_13 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_13 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_13 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x54000543 // b.lo LBB0_29 $168(%rip) +LBB0_13: + WORD $0x91000808 // add x8, x0, #2 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_17 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_17 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_17 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x540003e3 // b.lo LBB0_29 $124(%rip) +LBB0_17: + WORD $0x91000c08 // add x8, x0, #3 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_21 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_21 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_21 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x54000283 // b.lo LBB0_29 $80(%rip) +LBB0_21: + WORD $0x91001008 // add x8, x0, #4 + WORD $0xeb0801ff // cmp x15, x8 + WORD $0x5400ea69 // b.ls LBB0_386 $7500(%rip) + WORD $0x54000180 // b.eq LBB0_26 $48(%rip) + WORD $0x8b0f012a // add x10, x9, x15 +LBB0_24: + WORD $0x38e8692c // ldrsb w12, [x9, x8] + WORD $0x7100819f // cmp w12, #32 + WORD $0x9acc216c // lsl x12, x11, x12 + WORD $0x8a10018c // and x12, x12, x16 + WORD $0xfa409984 // ccmp x12, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_28 $28(%rip) + WORD $0x91000508 // add x8, x8, #1 + WORD $0xeb0801ff // cmp x15, x8 + WORD $0x54ffff01 // b.ne LBB0_24 $-32(%rip) + WORD $0x14000002 // b LBB0_27 $8(%rip) +LBB0_26: + WORD $0x8b08012a // add x10, x9, x8 +LBB0_27: + WORD $0xcb090148 // sub x8, x10, x9 +LBB0_28: + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x5400e882 // b.hs LBB0_387 $7440(%rip) +LBB0_29: + WORD $0x91000500 // add x0, x8, #1 + WORD $0xf9000020 // str x0, [x1] + WORD $0x8b080138 // add x24, x9, x8 + WORD $0x39c00307 // ldrsb w7, [x24] + WORD $0x3400e7e7 // cbz w7, LBB0_387 $7420(%rip) + WORD $0xd100072a // sub x10, x25, #1 + WORD $0x8b0a0c4c // add x12, x2, x10, lsl #3 + WORD $0xb8408d8d // ldr w13, [x12, #8]! + WORD $0xb10006ff // cmn x23, #1 + WORD $0x9a970117 // csel x23, x8, x23, eq + WORD $0x510005ad // sub w13, w13, #1 + WORD $0x710015bf // cmp w13, #5 + WORD $0x54000f48 // b.hi LBB0_53 $488(%rip) + WORD $0x1000008f // adr x15, LBB0_32 $16(%rip) + WORD $0x786d7893 // ldrh w19, [x4, x13, lsl #1] + WORD $0x8b1309ef // add x15, x15, x19, lsl #2 + WORD $0xd61f01e0 // br x15 +LBB0_32: + WORD $0x7100b0ff // cmp w7, #44 + WORD $0x540021e0 // b.eq LBB0_90 $1084(%rip) + WORD $0x710174ff // cmp w7, #93 + WORD $0x54002100 // b.eq LBB0_89 $1056(%rip) + WORD $0x1400073b // b LBB0_394 $7404(%rip) +LBB0_34: + WORD $0x7100b0ff // cmp w7, #44 + WORD $0x54002061 // b.ne LBB0_88 $1036(%rip) + WORD $0xf13fff3f // cmp x25, #4095 + WORD $0x5400e58c // b.gt LBB0_388 $7344(%rip) + WORD $0x91000728 // add x8, x25, #1 + WORD $0xf9000048 // str x8, [x2] + WORD $0x8b190c48 // add x8, x2, x25, lsl #3 + WORD $0x5280006a // mov w10, #3 + WORD $0x17ffff9d // b LBB0_2 $-396(%rip) +LBB0_37: + WORD $0x710088ff // cmp w7, #34 + WORD $0x5400e601 // b.ne LBB0_394 $7360(%rip) + WORD $0x5280008a // mov w10, #4 + WORD $0xf900018a // str x10, [x12] + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0001fa // subs x26, x15, x0 + WORD $0x37282c03 // tbnz w3, #5, LBB0_103 $1408(%rip) + WORD $0x5400f020 // b.eq LBB0_417 $7684(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x5400b8a3 // b.lo LBB0_315 $5908(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_42: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405554 // ldp q20, q21, [x10] + WORD $0xad415d56 // ldp q22, q23, [x10, #32] + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e208efb // cmeq.16b v27, v23, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x6e218ef7 // cmeq.16b v23, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x4e221f38 // and.16b v24, v25, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x4e221f58 // and.16b v24, v26, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x4e221f78 // and.16b v24, v27, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260293 // fmov w19, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26029c // fmov w28, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xd3607e6c // lsl x12, x19, #32 + WORD $0xb3503f8c // bfi x12, x28, #48, #16 + WORD $0x53103ced // lsl w13, w7, #16 + WORD $0xaa0d018c // orr x12, x12, x13 + WORD $0xaa11018c // orr x12, x12, x17 + WORD $0xb500010c // cbnz x12, LBB0_46 $32(%rip) + WORD $0xb50001bb // cbnz x27, LBB0_47 $52(%rip) + WORD $0xb50002ea // cbnz x10, LBB0_48 $92(%rip) +LBB0_45: + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff8a8 // b.hi LBB0_42 $-236(%rip) + WORD $0x140003f7 // b LBB0_238 $4060(%rip) +LBB0_46: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0018d // rbit x13, x12 + WORD $0xdac011ad // clz x13, x13 + WORD $0x8b0001ad // add x13, x13, x0 + WORD $0x9a8d1318 // csel x24, x24, x13, ne + WORD $0x9a8d1339 // csel x25, x25, x13, ne +LBB0_47: + WORD $0x8a3b018d // bic x13, x12, x27 + WORD $0xaa0d076e // orr x14, x27, x13, lsl #1 + WORD $0x8a2e018c // bic x12, x12, x14 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0d018c // adds x12, x12, x13 + WORD $0x1a9f37fb // cset w27, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0e018c // and x12, x12, x14 + WORD $0x8a2c014a // bic x10, x10, x12 + WORD $0xb4fffd6a // cbz x10, LBB0_45 $-84(%rip) +LBB0_48: + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x1400017d // b LBB0_115 $1524(%rip) +LBB0_49: + WORD $0x7100e8ff // cmp w7, #58 + WORD $0x5400da21 // b.ne LBB0_394 $6980(%rip) + WORD $0xf900019f // str xzr, [x12] + WORD $0x17ffff3b // b LBB0_3 $-788(%rip) +LBB0_51: + WORD $0x710174ff // cmp w7, #93 + WORD $0x54001320 // b.eq LBB0_89 $612(%rip) + WORD $0xf900018b // str x11, [x12] + WORD $0x14000002 // b LBB0_54 $8(%rip) +LBB0_53: + WORD $0xf900004a // str x10, [x2] +LBB0_54: + WORD $0x7101ecff // cmp w7, #123 + WORD $0x5400d908 // b.hi LBB0_394 $6944(%rip) + WORD $0x9280000f // mov x15, #-1 +Lloh12: + WORD $0x1000e58d // adr x13, LJTI0_1 $7344(%rip) +Lloh13: + WORD $0x910001ad // add x13, x13, LJTI0_1@PAGEOFF $0(%rip) + WORD $0x1000008a // adr x10, LBB0_56 $16(%rip) + WORD $0x786779ac // ldrh w12, [x13, x7, lsl #1] + WORD $0x8b0c094a // add x10, x10, x12, lsl #2 + WORD $0xd61f0140 // br x10 +LBB0_56: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xeb080153 // subs x19, x10, x8 + WORD $0x5400d740 // b.eq LBB0_391 $6888(%rip) + WORD $0x3940030a // ldrb w10, [x24] + WORD $0x7100c15f // cmp w10, #48 + WORD $0x54000181 // b.ne LBB0_61 $48(%rip) + WORD $0xf100067f // cmp x19, #1 + WORD $0x54003040 // b.eq LBB0_131 $1544(%rip) + WORD $0x3860692a // ldrb w10, [x9, x0] + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x54002fc8 // b.hi LBB0_131 $1528(%rip) + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xb20903ec // mov x12, #36028797027352576 + WORD $0xf280002c // movk x12, #1 + WORD $0xea0c015f // tst x10, x12 + WORD $0x54002f20 // b.eq LBB0_131 $1508(%rip) +LBB0_61: + WORD $0xf100427f // cmp x19, #16 + WORD $0x5400a3a3 // b.lo LBB0_301 $5236(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800019 // mov x25, #-1 + WORD $0x92800000 // mov x0, #-1 + WORD $0x9280000f // mov x15, #-1 + WORD $0xaa1303fa // mov x26, x19 +LBB0_63: + WORD $0x3cfb6b14 // ldr q20, [x24, x27] + WORD $0x6e258e95 // cmeq.16b v21, v20, v5 + WORD $0x6e268e96 // cmeq.16b v22, v20, v6 + WORD $0x6e278e97 // cmeq.16b v23, v20, v7 + WORD $0x4e308698 // add.16b v24, v20, v16 + WORD $0x6e383638 // cmhi.16b v24, v17, v24 + WORD $0x4e321e94 // and.16b v20, v20, v18 + WORD $0x6e338e94 // cmeq.16b v20, v20, v19 + WORD $0x4eb61ef6 // orr.16b v22, v23, v22 + WORD $0x4eb51e97 // orr.16b v23, v20, v21 + WORD $0x4eb61ef7 // orr.16b v23, v23, v22 + WORD $0x4eb81ef7 // orr.16b v23, v23, v24 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x2a2c03ec // mvn w12, w12 + WORD $0x32103d8c // orr w12, w12, #0xffff0000 + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac01187 // clz w7, w12 + WORD $0x1ac722ac // lsl w12, w21, w7 + WORD $0x0a2c0151 // bic w17, w10, w12 + WORD $0x0a2c01bc // bic w28, w13, w12 + WORD $0x0a2c01de // bic w30, w14, w12 + WORD $0x710040ff // cmp w7, #16 + WORD $0x1a91014c // csel w12, w10, w17, eq + WORD $0x1a9c01bc // csel w28, w13, w28, eq + WORD $0x1a9e01ca // csel w10, w14, w30, eq + WORD $0x5100058d // sub w13, w12, #1 + WORD $0x6a0c01ad // ands w13, w13, w12 + WORD $0x54007041 // b.ne LBB0_234 $3592(%rip) + WORD $0x5100078d // sub w13, w28, #1 + WORD $0x6a1c01ad // ands w13, w13, w28 + WORD $0x54006fe1 // b.ne LBB0_234 $3580(%rip) + WORD $0x5100054d // sub w13, w10, #1 + WORD $0x6a0a01ad // ands w13, w13, w10 + WORD $0x54006f81 // b.ne LBB0_234 $3568(%rip) + WORD $0x340000cc // cbz w12, LBB0_69 $24(%rip) + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb10005ff // cmn x15, #1 + WORD $0x54007c21 // b.ne LBB0_252 $3972(%rip) + WORD $0x8b0c036f // add x15, x27, x12 +LBB0_69: + WORD $0x340000dc // cbz w28, LBB0_72 $24(%rip) + WORD $0x5ac0038c // rbit w12, w28 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb100041f // cmn x0, #1 + WORD $0x54007b61 // b.ne LBB0_252 $3948(%rip) + WORD $0x8b0c0360 // add x0, x27, x12 +LBB0_72: + WORD $0x340000ca // cbz w10, LBB0_75 $24(%rip) + WORD $0x5ac0014a // rbit w10, w10 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x54008621 // b.ne LBB0_265 $4292(%rip) + WORD $0x8b0a0379 // add x25, x27, x10 +LBB0_75: + WORD $0x710040ff // cmp w7, #16 + WORD $0x540022c1 // b.ne LBB0_118 $1112(%rip) + WORD $0xd100435a // sub x26, x26, #16 + WORD $0x9100437b // add x27, x27, #16 + WORD $0xf1003f5f // cmp x26, #15 + WORD $0x54fff708 // b.hi LBB0_63 $-288(%rip) + WORD $0x8b1b0307 // add x7, x24, x27 + WORD $0xeb1b027f // cmp x19, x27 + WORD $0x54002220 // b.eq LBB0_119 $1092(%rip) +LBB0_78: + WORD $0x8b1a00ea // add x10, x7, x26 + WORD $0xf9401fec // ldr x12, [sp, #56] + WORD $0x8b08018c // add x12, x12, x8 + WORD $0xcb070193 // sub x19, x12, x7 + WORD $0xcb1800fb // sub x27, x7, x24 + WORD $0xaa0703fc // mov x28, x7 + WORD $0x1400000b // b LBB0_82 $44(%rip) +LBB0_79: + WORD $0x7101959f // cmp w12, #101 + WORD $0x54002101 // b.ne LBB0_119 $1056(%rip) +LBB0_80: + WORD $0xb100041f // cmn x0, #1 + WORD $0xaa1b03e0 // mov x0, x27 + WORD $0x54002301 // b.ne LBB0_129 $1120(%rip) +LBB0_81: + WORD $0xd1000673 // sub x19, x19, #1 + WORD $0x9100077b // add x27, x27, #1 + WORD $0xaa1c03e7 // mov x7, x28 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb40056fa // cbz x26, LBB0_191 $2780(%rip) +LBB0_82: + WORD $0x38c0178c // ldrsb w12, [x28], #1 + WORD $0x5100c18d // sub w13, w12, #48 + WORD $0x710029bf // cmp w13, #10 + WORD $0x54ffff03 // b.lo LBB0_81 $-32(%rip) + WORD $0x5100ad8d // sub w13, w12, #43 + WORD $0x710069bf // cmp w13, #26 + WORD $0x54fffe08 // b.hi LBB0_79 $-64(%rip) + WORD $0x10fffe2c // adr x12, LBB0_80 $-60(%rip) + WORD $0x786d7ace // ldrh w14, [x22, x13, lsl #1] + WORD $0x8b0e098c // add x12, x12, x14, lsl #2 + WORD $0xd61f0180 // br x12 +LBB0_85: + WORD $0xb100073f // cmn x25, #1 + WORD $0xaa1b03f9 // mov x25, x27 + WORD $0x54fffdc0 // b.eq LBB0_81 $-72(%rip) + WORD $0x14000104 // b LBB0_129 $1040(%rip) +LBB0_86: + WORD $0xb10005ff // cmn x15, #1 + WORD $0xaa1b03ef // mov x15, x27 + WORD $0x54fffd40 // b.eq LBB0_81 $-88(%rip) + WORD $0x14000100 // b LBB0_129 $1024(%rip) +LBB0_87: + WORD $0x710088ff // cmp w7, #34 + WORD $0x540001e0 // b.eq LBB0_92 $60(%rip) +LBB0_88: + WORD $0x7101f4ff // cmp w7, #125 + WORD $0x5400c6a1 // b.ne LBB0_394 $6356(%rip) +LBB0_89: + WORD $0xf900004a // str x10, [x2] + WORD $0xaa0a03f9 // mov x25, x10 + WORD $0xaa1703ef // mov x15, x23 + WORD $0xb5ffd40a // cbnz x10, LBB0_4 $-1408(%rip) + WORD $0x1400063e // b LBB0_400 $6392(%rip) +LBB0_90: + WORD $0xf13fff3f // cmp x25, #4095 + WORD $0x5400c46c // b.gt LBB0_388 $6284(%rip) + WORD $0x91000728 // add x8, x25, #1 + WORD $0xf9000048 // str x8, [x2] + WORD $0x8b190c48 // add x8, x2, x25, lsl #3 + WORD $0xf900051f // str xzr, [x8, #8] + WORD $0x17fffe95 // b LBB0_3 $-1452(%rip) +LBB0_92: + WORD $0x5280004a // mov w10, #2 + WORD $0xf900018a // str x10, [x12] + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0001fa // subs x26, x15, x0 + WORD $0x37281e23 // tbnz w3, #5, LBB0_132 $964(%rip) + WORD $0x5400cf40 // b.eq LBB0_417 $6632(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x540099e3 // b.lo LBB0_318 $4924(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_96: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405554 // ldp q20, q21, [x10] + WORD $0xad415d56 // ldp q22, q23, [x10, #32] + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e208efb // cmeq.16b v27, v23, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x6e218ef7 // cmeq.16b v23, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x4e221f38 // and.16b v24, v25, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x4e221f58 // and.16b v24, v26, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x4e221f78 // and.16b v24, v27, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260293 // fmov w19, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26029c // fmov w28, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xd3607e6c // lsl x12, x19, #32 + WORD $0xb3503f8c // bfi x12, x28, #48, #16 + WORD $0x53103ced // lsl w13, w7, #16 + WORD $0xaa0d018c // orr x12, x12, x13 + WORD $0xaa11018c // orr x12, x12, x17 + WORD $0xb500010c // cbnz x12, LBB0_100 $32(%rip) + WORD $0xb50001bb // cbnz x27, LBB0_101 $52(%rip) + WORD $0xb50002ea // cbnz x10, LBB0_102 $92(%rip) +LBB0_99: + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff8a8 // b.hi LBB0_96 $-236(%rip) + WORD $0x14000356 // b LBB0_254 $3416(%rip) +LBB0_100: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0018d // rbit x13, x12 + WORD $0xdac011ad // clz x13, x13 + WORD $0x8b0001ad // add x13, x13, x0 + WORD $0x9a8d1318 // csel x24, x24, x13, ne + WORD $0x9a8d1339 // csel x25, x25, x13, ne +LBB0_101: + WORD $0x8a3b018d // bic x13, x12, x27 + WORD $0xaa0d076e // orr x14, x27, x13, lsl #1 + WORD $0x8a2e018c // bic x12, x12, x14 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0d018c // adds x12, x12, x13 + WORD $0x1a9f37fb // cset w27, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0e018c // and x12, x12, x14 + WORD $0x8a2c014a // bic x10, x10, x12 + WORD $0xb4fffd6a // cbz x10, LBB0_99 $-84(%rip) +LBB0_102: + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x1400010e // b LBB0_144 $1080(%rip) +LBB0_103: + WORD $0x5400c440 // b.eq LBB0_417 $6280(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54008da3 // b.lo LBB0_316 $4532(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x9280001b // mov x27, #-1 +LBB0_106: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260307 // fmov w7, s24 + WORD $0x6e218ef8 // cmeq.16b v24, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0x6e218ed8 // cmeq.16b v24, v22, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031e // fmov w30, s24 + WORD $0x6e218eb8 // cmeq.16b v24, v21, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e218e98 // cmeq.16b v24, v20, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503ced // bfi x13, x7, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0193 // orr x19, x12, x10 + WORD $0xd3607e2a // lsl x10, x17, #32 + WORD $0xb3503dca // bfi x10, x14, #48, #16 + WORD $0x53103fcc // lsl w12, w30, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa1c014a // orr x10, x10, x28 + WORD $0xb500044a // cbnz x10, LBB0_111 $136(%rip) + WORD $0xb50004f9 // cbnz x25, LBB0_112 $156(%rip) +LBB0_108: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000313 // cbnz x19, LBB0_113 $96(%rip) + WORD $0xb500aeca // cbnz x10, LBB0_395 $5592(%rip) + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff568 // b.hi LBB0_106 $-340(%rip) + WORD $0x140002a1 // b LBB0_243 $2692(%rip) +LBB0_111: + WORD $0xb100077f // cmn x27, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c137b // csel x27, x27, x12, ne +LBB0_112: + WORD $0x8a39014c // bic x12, x10, x25 + WORD $0xaa0c072d // orr x13, x25, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a0273 // bic x19, x19, x10 + WORD $0x17ffffd0 // b LBB0_108 $-192(%rip) +LBB0_113: + WORD $0xdac0026c // rbit x12, x19 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x5400b623 // b.lo LBB0_418 $5828(%rip) + WORD $0x8b00018a // add x10, x12, x0 +LBB0_115: + WORD $0x91000540 // add x0, x10, #1 +LBB0_116: + WORD $0xb7f8a980 // tbnz x0, #63, LBB0_389 $5424(%rip) +LBB0_117: + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb27ff7ea // mov x10, #9223372036854775806 + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x54ffb789 // b.ls LBB0_3 $-2320(%rip) + WORD $0x1400055d // b LBB0_400 $5492(%rip) +LBB0_118: + WORD $0x8b27430a // add x10, x24, w7, uxtw + WORD $0x8b1b0147 // add x7, x10, x27 +LBB0_119: + WORD $0x92800013 // mov x19, #-1 + WORD $0xb400a90f // cbz x15, LBB0_392 $5408(%rip) +LBB0_120: + WORD $0xb400a8f9 // cbz x25, LBB0_392 $5404(%rip) + WORD $0xb400a8c0 // cbz x0, LBB0_392 $5400(%rip) + WORD $0xcb1800ea // sub x10, x7, x24 + WORD $0xd100054c // sub x12, x10, #1 + WORD $0xeb0c01ff // cmp x15, x12 + WORD $0x54000160 // b.eq LBB0_128 $44(%rip) + WORD $0xeb0c033f // cmp x25, x12 + WORD $0x54000120 // b.eq LBB0_128 $36(%rip) + WORD $0xeb0c001f // cmp x0, x12 + WORD $0x540000e0 // b.eq LBB0_128 $28(%rip) + WORD $0xf100072c // subs x12, x25, #1 + WORD $0x5400118b // b.lt LBB0_148 $560(%rip) + WORD $0xeb0c001f // cmp x0, x12 + WORD $0x54001140 // b.eq LBB0_148 $552(%rip) + WORD $0xaa3903f3 // mvn x19, x25 + WORD $0x14000002 // b LBB0_129 $8(%rip) +LBB0_128: + WORD $0xcb0a03f3 // neg x19, x10 +LBB0_129: + WORD $0xb7f8a6d3 // tbnz x19, #63, LBB0_392 $5336(%rip) + WORD $0x8b080260 // add x0, x19, x8 +LBB0_131: + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb6ffb428 // tbz x8, #63, LBB0_3 $-2428(%rip) + WORD $0x14000542 // b LBB0_400 $5384(%rip) +LBB0_132: + WORD $0x5400b140 // b.eq LBB0_417 $5672(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54007cc3 // b.lo LBB0_319 $3992(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x9280001b // mov x27, #-1 +LBB0_135: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x6e218ef8 // cmeq.16b v24, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e218ed8 // cmeq.16b v24, v22, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260307 // fmov w7, s24 + WORD $0x6e218eb8 // cmeq.16b v24, v21, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0x6e218e98 // cmeq.16b v24, v20, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031e // fmov w30, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0193 // orr x19, x12, x10 + WORD $0xd3607f8a // lsl x10, x28, #32 + WORD $0xb3503fca // bfi x10, x30, #48, #16 + WORD $0x53103cec // lsl w12, w7, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa11014a // orr x10, x10, x17 + WORD $0xb500044a // cbnz x10, LBB0_140 $136(%rip) + WORD $0xb50004f9 // cbnz x25, LBB0_141 $156(%rip) +LBB0_137: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000313 // cbnz x19, LBB0_142 $96(%rip) + WORD $0xb5009bca // cbnz x10, LBB0_395 $4984(%rip) + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff568 // b.hi LBB0_135 $-340(%rip) + WORD $0x1400026f // b LBB0_259 $2492(%rip) +LBB0_140: + WORD $0xb100077f // cmn x27, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c137b // csel x27, x27, x12, ne +LBB0_141: + WORD $0x8a39014c // bic x12, x10, x25 + WORD $0xaa0c072d // orr x13, x25, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a0273 // bic x19, x19, x10 + WORD $0x17ffffd0 // b LBB0_137 $-192(%rip) +LBB0_142: + WORD $0xdac0026c // rbit x12, x19 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x5400a323 // b.lo LBB0_418 $5220(%rip) + WORD $0x8b00018a // add x10, x12, x0 +LBB0_144: + WORD $0x91000540 // add x0, x10, #1 +LBB0_145: + WORD $0xb7f89680 // tbnz x0, #63, LBB0_389 $4816(%rip) + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb27ff7ea // mov x10, #9223372036854775806 + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x540098c8 // b.hi LBB0_400 $4888(%rip) + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x54ffa38d // b.le LBB0_1 $-2960(%rip) + WORD $0x140004a9 // b LBB0_388 $4772(%rip) +LBB0_148: + WORD $0xaa0001ec // orr x12, x15, x0 + WORD $0xb7f813ac // tbnz x12, #63, LBB0_178 $628(%rip) + WORD $0xeb0001ff // cmp x15, x0 + WORD $0x5400136b // b.lt LBB0_178 $620(%rip) + WORD $0xaa2f03f3 // mvn x19, x15 + WORD $0x17ffff75 // b LBB0_129 $-556(%rip) +LBB0_151: + WORD $0xf94004cf // ldr x15, [x6, #8] + WORD $0xeb0001fa // subs x26, x15, x0 + WORD $0x372813c3 // tbnz w3, #5, LBB0_179 $632(%rip) + WORD $0x5400a020 // b.eq LBB0_417 $5124(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54006d23 // b.lo LBB0_321 $3492(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_155: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405554 // ldp q20, q21, [x10] + WORD $0xad415d56 // ldp q22, q23, [x10, #32] + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x6e208eb9 // cmeq.16b v25, v21, v0 + WORD $0x6e208eda // cmeq.16b v26, v22, v0 + WORD $0x6e208efb // cmeq.16b v27, v23, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x6e218ed6 // cmeq.16b v22, v22, v1 + WORD $0x6e218ef7 // cmeq.16b v23, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x4e221f38 // and.16b v24, v25, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x4e221f58 // and.16b v24, v26, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x4e221f78 // and.16b v24, v27, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260285 // fmov w5, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260293 // fmov w19, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xd3607cec // lsl x12, x7, #32 + WORD $0xb3503e6c // bfi x12, x19, #48, #16 + WORD $0x53103cad // lsl w13, w5, #16 + WORD $0xaa0d018c // orr x12, x12, x13 + WORD $0xaa11018c // orr x12, x12, x17 + WORD $0xb500010c // cbnz x12, LBB0_159 $32(%rip) + WORD $0xb50001bb // cbnz x27, LBB0_160 $52(%rip) + WORD $0xb50002ea // cbnz x10, LBB0_161 $92(%rip) +LBB0_158: + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff8a8 // b.hi LBB0_155 $-236(%rip) + WORD $0x14000280 // b LBB0_290 $2560(%rip) +LBB0_159: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0018d // rbit x13, x12 + WORD $0xdac011ad // clz x13, x13 + WORD $0x8b0001ad // add x13, x13, x0 + WORD $0x9a8d1318 // csel x24, x24, x13, ne + WORD $0x9a8d1339 // csel x25, x25, x13, ne +LBB0_160: + WORD $0x8a3b018d // bic x13, x12, x27 + WORD $0xaa0d076e // orr x14, x27, x13, lsl #1 + WORD $0x8a2e018c // bic x12, x12, x14 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab0d018c // adds x12, x12, x13 + WORD $0x1a9f37fb // cset w27, hs + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xd200f18c // eor x12, x12, #0x5555555555555555 + WORD $0x8a0e018c // and x12, x12, x14 + WORD $0x8a2c014a // bic x10, x10, x12 + WORD $0xb4fffd6a // cbz x10, LBB0_158 $-84(%rip) +LBB0_161: + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x91000540 // add x0, x10, #1 + WORD $0xb6ffdfc0 // tbz x0, #63, LBB0_117 $-1032(%rip) + WORD $0x14000448 // b LBB0_389 $4384(%rip) +LBB0_162: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xeb00014f // subs x15, x10, x0 + WORD $0x54008ca0 // b.eq LBB0_401 $4500(%rip) + WORD $0x8b000127 // add x7, x9, x0 + WORD $0x394000ea // ldrb w10, [x7] + WORD $0x7100c15f // cmp w10, #48 + WORD $0x54001861 // b.ne LBB0_194 $780(%rip) + WORD $0xf10005ff // cmp x15, #1 + WORD $0x540016e1 // b.ne LBB0_192 $732(%rip) +LBB0_165: + WORD $0x5280003b // mov w27, #1 + WORD $0x140001b2 // b LBB0_251 $1736(%rip) +LBB0_166: + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x5400870c // b.gt LBB0_388 $4320(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x528000aa // mov w10, #5 + WORD $0x17fffca9 // b LBB0_2 $-3420(%rip) +LBB0_168: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xd100114c // sub x12, x10, #4 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x54008802 // b.hs LBB0_397 $4352(%rip) + WORD $0xb860692a // ldr w10, [x9, x0] + WORD $0x528d8c2c // mov w12, #27745 + WORD $0x72acae6c // movk w12, #25971, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x540089e1 // b.ne LBB0_403 $4412(%rip) + WORD $0x91001500 // add x0, x8, #5 + WORD $0x17fffedf // b LBB0_117 $-1156(%rip) +LBB0_171: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xd1000d4c // sub x12, x10, #3 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x540086a2 // b.hs LBB0_397 $4308(%rip) + WORD $0xb940030a // ldr w10, [x24] + WORD $0x528eadcc // mov w12, #30062 + WORD $0x72ad8d8c // movk w12, #27756, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x54000160 // b.eq LBB0_175 $44(%rip) + WORD $0x14000457 // b LBB0_408 $4444(%rip) +LBB0_173: + WORD $0xf94004ca // ldr x10, [x6, #8] + WORD $0xd1000d4c // sub x12, x10, #3 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x54008562 // b.hs LBB0_397 $4268(%rip) + WORD $0xb940030a // ldr w10, [x24] + WORD $0x528e4e8c // mov w12, #29300 + WORD $0x72acaeac // movk w12, #25973, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x54008c41 // b.ne LBB0_412 $4488(%rip) +LBB0_175: + WORD $0x91001100 // add x0, x8, #4 + WORD $0x17fffeca // b LBB0_117 $-1240(%rip) +LBB0_176: + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x5400820c // b.gt LBB0_388 $4160(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x528000ca // mov w10, #6 + WORD $0x17fffc81 // b LBB0_2 $-3580(%rip) +LBB0_178: + WORD $0xd37ffd8c // lsr x12, x12, #63 + WORD $0x5200018c // eor w12, w12, #0x1 + WORD $0xd100040d // sub x13, x0, #1 + WORD $0xeb0d01ff // cmp x15, x13 + WORD $0x1a9f17ed // cset w13, eq + WORD $0x6a0d019f // tst w12, w13 + WORD $0xda800153 // csinv x19, x10, x0, eq + WORD $0x17fffed5 // b LBB0_129 $-1196(%rip) +LBB0_179: + WORD $0x54008c80 // b.eq LBB0_417 $4496(%rip) + WORD $0xf101035f // cmp x26, #64 + WORD $0x54005a63 // b.lo LBB0_322 $2892(%rip) + WORD $0xd2800019 // mov x25, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x9280001b // mov x27, #-1 +LBB0_182: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x6e218ef8 // cmeq.16b v24, v23, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e218ed8 // cmeq.16b v24, v22, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260305 // fmov w5, s24 + WORD $0x6e218eb8 // cmeq.16b v24, v21, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260307 // fmov w7, s24 + WORD $0x6e218e98 // cmeq.16b v24, v20, v1 + WORD $0x4e221f18 // and.16b v24, v24, v2 + WORD $0x4e030318 // tbl.16b v24, { v24 }, v3 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0193 // orr x19, x12, x10 + WORD $0xd3607cea // lsl x10, x7, #32 + WORD $0xb3503f8a // bfi x10, x28, #48, #16 + WORD $0x53103cac // lsl w12, w5, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa11014a // orr x10, x10, x17 + WORD $0xb500044a // cbnz x10, LBB0_187 $136(%rip) + WORD $0xb50004f9 // cbnz x25, LBB0_188 $156(%rip) +LBB0_184: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e221ef7 // and.16b v23, v23, v2 + WORD $0x4e0302f7 // tbl.16b v23, { v23 }, v3 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000313 // cbnz x19, LBB0_189 $96(%rip) + WORD $0xb500770a // cbnz x10, LBB0_395 $3808(%rip) + WORD $0xd101035a // sub x26, x26, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff5f // cmp x26, #63 + WORD $0x54fff568 // b.hi LBB0_182 $-340(%rip) + WORD $0x140001ed // b LBB0_295 $1972(%rip) +LBB0_187: + WORD $0xb100077f // cmn x27, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c137b // csel x27, x27, x12, ne +LBB0_188: + WORD $0x8a39014c // bic x12, x10, x25 + WORD $0xaa0c072d // orr x13, x25, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a0273 // bic x19, x19, x10 + WORD $0x17ffffd0 // b LBB0_184 $-192(%rip) +LBB0_189: + WORD $0xdac0026c // rbit x12, x19 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54007e63 // b.lo LBB0_418 $4044(%rip) + WORD $0x8b00018a // add x10, x12, x0 + WORD $0x91000540 // add x0, x10, #1 + WORD $0xb6ffc860 // tbz x0, #63, LBB0_117 $-1780(%rip) + WORD $0x1400038d // b LBB0_389 $3636(%rip) +LBB0_191: + WORD $0xaa0a03e7 // mov x7, x10 + WORD $0x92800013 // mov x19, #-1 + WORD $0xb5ffc92f // cbnz x15, LBB0_120 $-1756(%rip) + WORD $0x1400038f // b LBB0_392 $3644(%rip) +LBB0_192: + WORD $0x394004ea // ldrb w10, [x7, #1] + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x54ffe8e8 // b.hi LBB0_165 $-740(%rip) + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0x5280003b // mov w27, #1 + WORD $0xb20903ec // mov x12, #36028797027352576 + WORD $0xf280002c // movk x12, #1 + WORD $0xea0c015f // tst x10, x12 + WORD $0x54001e80 // b.eq LBB0_251 $976(%rip) +LBB0_194: + WORD $0xf10041ff // cmp x15, #16 + WORD $0x54004823 // b.lo LBB0_320 $2308(%rip) + WORD $0xd280001c // mov x28, #0 + WORD $0x9280001a // mov x26, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0x92800018 // mov x24, #-1 + WORD $0xaa0f03fb // mov x27, x15 +LBB0_196: + WORD $0x3cfc68f4 // ldr q20, [x7, x28] + WORD $0x6e258e95 // cmeq.16b v21, v20, v5 + WORD $0x6e268e96 // cmeq.16b v22, v20, v6 + WORD $0x6e278e97 // cmeq.16b v23, v20, v7 + WORD $0x4e308698 // add.16b v24, v20, v16 + WORD $0x6e383638 // cmhi.16b v24, v17, v24 + WORD $0x4e321e94 // and.16b v20, v20, v18 + WORD $0x6e338e94 // cmeq.16b v20, v20, v19 + WORD $0x4eb61ef6 // orr.16b v22, v23, v22 + WORD $0x4eb51e97 // orr.16b v23, v20, v21 + WORD $0x4eb61ef7 // orr.16b v23, v23, v22 + WORD $0x4eb81ef7 // orr.16b v23, v23, v24 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x4e221ed4 // and.16b v20, v22, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0x4e221ef4 // and.16b v20, v23, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x2a2d03ed // mvn w13, w13 + WORD $0x32103dad // orr w13, w13, #0xffff0000 + WORD $0x5ac001ad // rbit w13, w13 + WORD $0x5ac011b3 // clz w19, w13 + WORD $0x1ad322ad // lsl w13, w21, w19 + WORD $0x0a2d0151 // bic w17, w10, w13 + WORD $0x0a2d019e // bic w30, w12, w13 + WORD $0x0a2d01c5 // bic w5, w14, w13 + WORD $0x7100427f // cmp w19, #16 + WORD $0x1a91014d // csel w13, w10, w17, eq + WORD $0x1a9e018c // csel w12, w12, w30, eq + WORD $0x1a8501ca // csel w10, w14, w5, eq + WORD $0x510005ae // sub w14, w13, #1 + WORD $0x6a0d01de // ands w30, w14, w13 + WORD $0x54002c81 // b.ne LBB0_287 $1424(%rip) + WORD $0x5100058e // sub w14, w12, #1 + WORD $0x6a0c01de // ands w30, w14, w12 + WORD $0x54002c21 // b.ne LBB0_287 $1412(%rip) + WORD $0x5100054e // sub w14, w10, #1 + WORD $0x6a0a01de // ands w30, w14, w10 + WORD $0x54002bc1 // b.ne LBB0_287 $1400(%rip) + WORD $0x340000cd // cbz w13, LBB0_202 $24(%rip) + WORD $0x5ac001ad // rbit w13, w13 + WORD $0x5ac011ad // clz w13, w13 + WORD $0xb100071f // cmn x24, #1 + WORD $0x54003801 // b.ne LBB0_302 $1792(%rip) + WORD $0x8b0d0398 // add x24, x28, x13 +LBB0_202: + WORD $0x340000cc // cbz w12, LBB0_205 $24(%rip) + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb100073f // cmn x25, #1 + WORD $0x540037a1 // b.ne LBB0_303 $1780(%rip) + WORD $0x8b0c0399 // add x25, x28, x12 +LBB0_205: + WORD $0x340000ca // cbz w10, LBB0_208 $24(%rip) + WORD $0x5ac0014a // rbit w10, w10 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb100075f // cmn x26, #1 + WORD $0x54003741 // b.ne LBB0_304 $1768(%rip) + WORD $0x8b0a039a // add x26, x28, x10 +LBB0_208: + WORD $0x7100427f // cmp w19, #16 + WORD $0x54000541 // b.ne LBB0_223 $168(%rip) + WORD $0xd100437b // sub x27, x27, #16 + WORD $0x9100439c // add x28, x28, #16 + WORD $0xf1003f7f // cmp x27, #15 + WORD $0x54fff708 // b.hi LBB0_196 $-288(%rip) + WORD $0x8b1c00f3 // add x19, x7, x28 + WORD $0xeb1c01ff // cmp x15, x28 + WORD $0x540004a0 // b.eq LBB0_224 $148(%rip) +LBB0_211: + WORD $0x8b1b026e // add x14, x19, x27 + WORD $0xf9401bea // ldr x10, [sp, #48] + WORD $0x8b13014a // add x10, x10, x19 + WORD $0xcb08015c // sub x28, x10, x8 + WORD $0xaa1303ef // mov x15, x19 + WORD $0x14000008 // b LBB0_215 $32(%rip) +LBB0_212: + WORD $0xb100075f // cmn x26, #1 + WORD $0x54002861 // b.ne LBB0_289 $1292(%rip) + WORD $0xd100079a // sub x26, x28, #1 +LBB0_214: + WORD $0x9100079c // add x28, x28, #1 + WORD $0xaa0f03f3 // mov x19, x15 + WORD $0xd100077b // sub x27, x27, #1 + WORD $0xb400133b // cbz x27, LBB0_253 $612(%rip) +LBB0_215: + WORD $0x38c015ea // ldrsb w10, [x15], #1 + WORD $0x5100c14c // sub w12, w10, #48 + WORD $0x7100299f // cmp w12, #10 + WORD $0x54ffff23 // b.lo LBB0_214 $-28(%rip) + WORD $0x5100ad4c // sub w12, w10, #43 + WORD $0x7100699f // cmp w12, #26 + WORD $0x54000128 // b.hi LBB0_220 $36(%rip) + WORD $0x10fffe4a // adr x10, LBB0_212 $-56(%rip) + WORD $0x386c6a8d // ldrb w13, [x20, x12] + WORD $0x8b0d094a // add x10, x10, x13, lsl #2 + WORD $0xd61f0140 // br x10 +LBB0_218: + WORD $0xb100071f // cmn x24, #1 + WORD $0x54002621 // b.ne LBB0_289 $1220(%rip) + WORD $0xd1000798 // sub x24, x28, #1 + WORD $0x17ffffee // b LBB0_214 $-72(%rip) +LBB0_220: + WORD $0x7101955f // cmp w10, #101 + WORD $0x540000e1 // b.ne LBB0_224 $28(%rip) +LBB0_221: + WORD $0xb100073f // cmn x25, #1 + WORD $0x54002561 // b.ne LBB0_289 $1196(%rip) + WORD $0xd1000799 // sub x25, x28, #1 + WORD $0x17ffffe8 // b LBB0_214 $-96(%rip) +LBB0_223: + WORD $0x8b3340ea // add x10, x7, w19, uxtw + WORD $0x8b1c0153 // add x19, x10, x28 +LBB0_224: + WORD $0x9280001b // mov x27, #-1 + WORD $0xb40064f8 // cbz x24, LBB0_402 $3228(%rip) +LBB0_225: + WORD $0xb40064da // cbz x26, LBB0_402 $3224(%rip) + WORD $0xb40064b9 // cbz x25, LBB0_402 $3220(%rip) + WORD $0xcb07026a // sub x10, x19, x7 + WORD $0xd100054c // sub x12, x10, #1 + WORD $0xeb0c031f // cmp x24, x12 + WORD $0x54000160 // b.eq LBB0_233 $44(%rip) + WORD $0xeb0c035f // cmp x26, x12 + WORD $0x54000120 // b.eq LBB0_233 $36(%rip) + WORD $0xeb0c033f // cmp x25, x12 + WORD $0x540000e0 // b.eq LBB0_233 $28(%rip) + WORD $0xf100074c // subs x12, x26, #1 + WORD $0x5400018b // b.lt LBB0_235 $48(%rip) + WORD $0xeb0c033f // cmp x25, x12 + WORD $0x54000140 // b.eq LBB0_235 $40(%rip) + WORD $0xaa3a03fb // mvn x27, x26 + WORD $0x1400006a // b LBB0_250 $424(%rip) +LBB0_233: + WORD $0xcb0a03fb // neg x27, x10 + WORD $0x14000068 // b LBB0_250 $416(%rip) +LBB0_234: + WORD $0x5ac001aa // rbit w10, w13 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3b03ec // mvn x12, x27 + WORD $0xcb0a0193 // sub x19, x12, x10 + WORD $0x17fffdbf // b LBB0_129 $-2308(%rip) +LBB0_235: + WORD $0xaa19030c // orr x12, x24, x25 + WORD $0xb7f80b4c // tbnz x12, #63, LBB0_249 $360(%rip) + WORD $0xeb19031f // cmp x24, x25 + WORD $0x54000b0b // b.lt LBB0_249 $352(%rip) + WORD $0xaa3803fb // mvn x27, x24 + WORD $0x1400005d // b LBB0_250 $372(%rip) +LBB0_238: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54003a63 // b.lo LBB0_326 $1868(%rip) +LBB0_239: + WORD $0xad405414 // ldp q20, q21, [x0] + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e208eb7 // cmeq.16b v23, v21, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c7 // fmov w7, s22 + WORD $0x4e221ef6 // and.16b v22, v23, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x33103d87 // bfi w7, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350034aa // cbnz w10, LBB0_323 $1684(%rip) + WORD $0xb500357b // cbnz x27, LBB0_324 $1708(%rip) + WORD $0xb40036e7 // cbz x7, LBB0_325 $1756(%rip) +LBB0_242: + WORD $0xdac000ea // rbit x10, x7 + WORD $0xdac0114a // clz x10, x10 + WORD $0xf94017ec // ldr x12, [sp, #40] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a0180 // add x0, x12, x10 + WORD $0x17fffd7a // b LBB0_116 $-2584(%rip) +LBB0_243: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54001383 // b.lo LBB0_268 $624(%rip) +LBB0_244: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602da // fmov w26, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e218eb6 // cmeq.16b v22, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e218e96 // cmeq.16b v22, v20, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cd // fmov w13, s22 + WORD $0x33103d9a // bfi w26, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350037aa // cbnz w10, LBB0_338 $1780(%rip) + WORD $0xb5003859 // cbnz x25, LBB0_339 $1800(%rip) +LBB0_246: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb4000e5a // cbz x26, LBB0_266 $456(%rip) + WORD $0xdac0034c // rbit x12, x26 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54005fa3 // b.lo LBB0_419 $3060(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0x17fffd48 // b LBB0_116 $-2784(%rip) +LBB0_249: + WORD $0xd37ffd8c // lsr x12, x12, #63 + WORD $0x5200018c // eor w12, w12, #0x1 + WORD $0xd100072d // sub x13, x25, #1 + WORD $0xeb0d031f // cmp x24, x13 + WORD $0x1a9f17ed // cset w13, eq + WORD $0x6a0d019f // tst w12, w13 + WORD $0xda99015b // csinv x27, x10, x25, eq +LBB0_250: + WORD $0xb7f855bb // tbnz x27, #63, LBB0_402 $2740(%rip) +LBB0_251: + WORD $0x8b000360 // add x0, x27, x0 + WORD $0x17fffd3f // b LBB0_117 $-2820(%rip) +LBB0_252: + WORD $0xaa3b03ea // mvn x10, x27 + WORD $0xcb2c4153 // sub x19, x10, w12, uxtw + WORD $0x17fffd57 // b LBB0_129 $-2724(%rip) +LBB0_253: + WORD $0xaa0e03f3 // mov x19, x14 + WORD $0x9280001b // mov x27, #-1 + WORD $0xb5ffeff8 // cbnz x24, LBB0_225 $-516(%rip) + WORD $0x140002a4 // b LBB0_402 $2704(%rip) +LBB0_254: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54003763 // b.lo LBB0_343 $1772(%rip) +LBB0_255: + WORD $0xad405414 // ldp q20, q21, [x0] + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e208eb7 // cmeq.16b v23, v21, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c7 // fmov w7, s22 + WORD $0x4e221ef6 // and.16b v22, v23, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x33103d87 // bfi w7, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350031aa // cbnz w10, LBB0_340 $1588(%rip) + WORD $0xb500327b // cbnz x27, LBB0_341 $1612(%rip) + WORD $0xb40033e7 // cbz x7, LBB0_342 $1660(%rip) +LBB0_258: + WORD $0xdac000ea // rbit x10, x7 + WORD $0xdac0114a // clz x10, x10 + WORD $0xf94017ec // ldr x12, [sp, #40] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a0180 // add x0, x12, x10 + WORD $0x17fffdac // b LBB0_145 $-2384(%rip) +LBB0_259: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54000b03 // b.lo LBB0_279 $352(%rip) +LBB0_260: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602da // fmov w26, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e218eb6 // cmeq.16b v22, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e218e96 // cmeq.16b v22, v20, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cd // fmov w13, s22 + WORD $0x33103d9a // bfi w26, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x350034aa // cbnz w10, LBB0_355 $1684(%rip) + WORD $0xb5003559 // cbnz x25, LBB0_356 $1704(%rip) +LBB0_262: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb40005da // cbz x26, LBB0_277 $184(%rip) + WORD $0xdac0034c // rbit x12, x26 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x540052e3 // b.lo LBB0_419 $2652(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0x17fffd7a // b LBB0_145 $-2584(%rip) +LBB0_265: + WORD $0xaa3b03ec // mvn x12, x27 + WORD $0xcb2a4193 // sub x19, x12, w10, uxtw + WORD $0x17fffcfb // b LBB0_129 $-3092(%rip) +LBB0_266: + WORD $0x350051ec // cbnz w12, LBB0_419 $2620(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_268: + WORD $0xb5003499 // cbnz x25, LBB0_359 $1680(%rip) + WORD $0xb400451a // cbz x26, LBB0_390 $2208(%rip) +LBB0_270: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x54000300 // b.eq LBB0_276 $96(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_274 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54005109 // b.ls LBB0_420 $2592(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffea1 // b.ne LBB0_270 $-44(%rip) + WORD $0x1400021b // b LBB0_390 $2156(%rip) +LBB0_274: + WORD $0xf100075f // cmp x26, #1 + WORD $0x54004320 // b.eq LBB0_390 $2148(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8a1318 // csel x24, x24, x10, ne + WORD $0x5280004a // mov w10, #2 + WORD $0x9a8a114c // csel x12, x10, x10, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffd01 // b.ne LBB0_270 $-96(%rip) + WORD $0x1400020e // b LBB0_390 $2104(%rip) +LBB0_276: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0x17fffcbd // b LBB0_116 $-3340(%rip) +LBB0_277: + WORD $0x35004dac // cbnz w12, LBB0_419 $2484(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_279: + WORD $0xb50032b9 // cbnz x25, LBB0_363 $1620(%rip) + WORD $0xb40040da // cbz x26, LBB0_390 $2072(%rip) +LBB0_281: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x540003a0 // b.eq LBB0_288 $116(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_285 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54004cc9 // b.ls LBB0_420 $2456(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffea1 // b.ne LBB0_281 $-44(%rip) + WORD $0x140001f9 // b LBB0_390 $2020(%rip) +LBB0_285: + WORD $0xf100075f // cmp x26, #1 + WORD $0x54003ee0 // b.eq LBB0_390 $2012(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8a1318 // csel x24, x24, x10, ne + WORD $0x5280004a // mov w10, #2 + WORD $0x9a8a114c // csel x12, x10, x10, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffd01 // b.ne LBB0_281 $-96(%rip) + WORD $0x140001ec // b LBB0_390 $1968(%rip) +LBB0_287: + WORD $0x5ac003ca // rbit w10, w30 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3c03ec // mvn x12, x28 + WORD $0xcb0a019b // sub x27, x12, x10 + WORD $0x17ffff59 // b LBB0_250 $-668(%rip) +LBB0_288: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0x17fffd2e // b LBB0_145 $-2888(%rip) +LBB0_289: + WORD $0xcb1c03fb // neg x27, x28 + WORD $0x17ffff54 // b LBB0_250 $-688(%rip) +LBB0_290: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54003183 // b.lo LBB0_368 $1584(%rip) +LBB0_291: + WORD $0xad405414 // ldp q20, q21, [x0] + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x6e208eb7 // cmeq.16b v23, v21, v0 + WORD $0x6e218e94 // cmeq.16b v20, v20, v1 + WORD $0x6e218eb5 // cmeq.16b v21, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c7 // fmov w7, s22 + WORD $0x4e221ef6 // and.16b v22, v23, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x4e221eb4 // and.16b v20, v21, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x33103d87 // bfi w7, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x35002bca // cbnz w10, LBB0_365 $1400(%rip) + WORD $0xb5002c9b // cbnz x27, LBB0_366 $1424(%rip) + WORD $0xb4002e07 // cbz x7, LBB0_367 $1472(%rip) +LBB0_294: + WORD $0xdac000ea // rbit x10, x7 + WORD $0xdac0114a // clz x10, x10 + WORD $0xf94017ec // ldr x12, [sp, #40] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a0180 // add x0, x12, x10 + WORD $0xb6ff8e40 // tbz x0, #63, LBB0_117 $-3640(%rip) + WORD $0x140001bc // b LBB0_389 $1776(%rip) +LBB0_295: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54000863 // b.lo LBB0_307 $268(%rip) +LBB0_296: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602da // fmov w26, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e218eb6 // cmeq.16b v22, v21, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e218e96 // cmeq.16b v22, v20, v1 + WORD $0x4e221ed6 // and.16b v22, v22, v2 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cd // fmov w13, s22 + WORD $0x33103d9a // bfi w26, w12, #16, #16 + WORD $0x33103daa // bfi w10, w13, #16, #16 + WORD $0x35002eca // cbnz w10, LBB0_380 $1496(%rip) + WORD $0xb5002f79 // cbnz x25, LBB0_381 $1516(%rip) +LBB0_298: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e221eb5 // and.16b v21, v21, v2 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e221e94 // and.16b v20, v20, v2 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb400033a // cbz x26, LBB0_305 $100(%rip) + WORD $0xdac0034c // rbit x12, x26 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54003e63 // b.lo LBB0_419 $1996(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0xb6ff87e0 // tbz x0, #63, LBB0_117 $-3844(%rip) + WORD $0x14000189 // b LBB0_389 $1572(%rip) +LBB0_301: + WORD $0x9280000f // mov x15, #-1 + WORD $0xaa1803e7 // mov x7, x24 + WORD $0xaa1303fa // mov x26, x19 + WORD $0x92800000 // mov x0, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0x17fffb30 // b LBB0_78 $-4928(%rip) +LBB0_302: + WORD $0xaa3c03ea // mvn x10, x28 + WORD $0xcb2d415b // sub x27, x10, w13, uxtw + WORD $0x17fffef4 // b LBB0_250 $-1072(%rip) +LBB0_303: + WORD $0xaa3c03ea // mvn x10, x28 + WORD $0xcb2c415b // sub x27, x10, w12, uxtw + WORD $0x17fffef1 // b LBB0_250 $-1084(%rip) +LBB0_304: + WORD $0xaa3c03ec // mvn x12, x28 + WORD $0xcb2a419b // sub x27, x12, w10, uxtw + WORD $0x17fffeee // b LBB0_250 $-1096(%rip) +LBB0_305: + WORD $0x35003bcc // cbnz w12, LBB0_419 $1912(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_307: + WORD $0xb5002bd9 // cbnz x25, LBB0_382 $1400(%rip) + WORD $0xb4002efa // cbz x26, LBB0_390 $1500(%rip) +LBB0_309: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x540004a0 // b.eq LBB0_317 $148(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_313 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54003ae9 // b.ls LBB0_420 $1884(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffea1 // b.ne LBB0_309 $-44(%rip) + WORD $0x1400016a // b LBB0_390 $1448(%rip) +LBB0_313: + WORD $0xf100075f // cmp x26, #1 + WORD $0x54002d00 // b.eq LBB0_390 $1440(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8a1318 // csel x24, x24, x10, ne + WORD $0x5280004a // mov w10, #2 + WORD $0x9a8a114c // csel x12, x10, x10, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab1a015a // adds x26, x10, x26 + WORD $0x54fffd01 // b.ne LBB0_309 $-96(%rip) + WORD $0x1400015d // b LBB0_390 $1396(%rip) +LBB0_315: + WORD $0xd280001b // mov x27, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffce02 // b.hs LBB0_239 $-1600(%rip) + WORD $0x14000041 // b LBB0_326 $260(%rip) +LBB0_316: + WORD $0xd2800019 // mov x25, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffd1a2 // b.hs LBB0_244 $-1484(%rip) + WORD $0x17ffff27 // b LBB0_268 $-868(%rip) +LBB0_317: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0xb6ff8000 // tbz x0, #63, LBB0_117 $-4096(%rip) + WORD $0x1400014a // b LBB0_389 $1320(%rip) +LBB0_318: + WORD $0xd280001b // mov x27, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffd8a2 // b.hs LBB0_255 $-1260(%rip) + WORD $0x1400007e // b LBB0_343 $504(%rip) +LBB0_319: + WORD $0xd2800019 // mov x25, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffdc42 // b.hs LBB0_260 $-1144(%rip) + WORD $0x17ffff38 // b LBB0_279 $-800(%rip) +LBB0_320: + WORD $0x92800018 // mov x24, #-1 + WORD $0xaa0703f3 // mov x19, x7 + WORD $0xaa0f03fb // mov x27, x15 + WORD $0x92800019 // mov x25, #-1 + WORD $0x9280001a // mov x26, #-1 + WORD $0x17fffe0c // b LBB0_211 $-2000(%rip) +LBB0_321: + WORD $0xd280001b // mov x27, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800019 // mov x25, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffeaa2 // b.hs LBB0_291 $-684(%rip) + WORD $0x140000df // b LBB0_368 $892(%rip) +LBB0_322: + WORD $0xd2800019 // mov x25, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800018 // mov x24, #-1 + WORD $0xf1008353 // subs x19, x26, #32 + WORD $0x54ffee62 // b.hs LBB0_296 $-564(%rip) + WORD $0x17ffffb4 // b LBB0_307 $-304(%rip) +LBB0_323: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0d018c // add x12, x12, x13 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_324: + WORD $0x0a3b014c // bic w12, w10, w27 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f799b // bfi w27, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a1b014a // and w10, w10, w27 + WORD $0x1a9f37fb // cset w27, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a070147 // and x7, x10, x7 + WORD $0xb5ffc967 // cbnz x7, LBB0_242 $-1748(%rip) +LBB0_325: + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_326: + WORD $0xb50010db // cbnz x27, LBB0_357 $536(%rip) + WORD $0xb40003da // cbz x26, LBB0_335 $120(%rip) +LBB0_328: + WORD $0xd280000a // mov x10, #0 +LBB0_329: + WORD $0x386a680c // ldrb w12, [x0, x10] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_334 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_332 $20(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xeb0a035f // cmp x26, x10 + WORD $0x54ffff21 // b.ne LBB0_329 $-28(%rip) + WORD $0x14000016 // b LBB0_336 $88(%rip) +LBB0_332: + WORD $0xd100074c // sub x12, x26, #1 + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x540020e0 // b.eq LBB0_390 $1052(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a018c // add x12, x12, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980198 // csel x24, x12, x24, eq + WORD $0x9a990199 // csel x25, x12, x25, eq + WORD $0x8b0a000c // add x12, x0, x10 + WORD $0x91000980 // add x0, x12, #2 + WORD $0xcb0a034c // sub x12, x26, x10 + WORD $0xd1000b4d // sub x13, x26, #2 + WORD $0xd100099a // sub x26, x12, #2 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54fffce1 // b.ne LBB0_328 $-100(%rip) + WORD $0x140000f9 // b LBB0_390 $996(%rip) +LBB0_334: + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0x91000540 // add x0, x10, #1 +LBB0_335: + WORD $0xcb090000 // sub x0, x0, x9 + WORD $0x17fffba7 // b LBB0_116 $-4452(%rip) +LBB0_336: + WORD $0x7100899f // cmp w12, #34 + WORD $0x54001e61 // b.ne LBB0_390 $972(%rip) + WORD $0x8b1a0000 // add x0, x0, x26 + WORD $0x17fffffb // b LBB0_335 $-20(%rip) +LBB0_338: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne +LBB0_339: + WORD $0x0a39014c // bic w12, w10, w25 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f7999 // bfi w25, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a19014a // and w10, w10, w25 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a1a015a // and x26, x10, x26 + WORD $0x17fffe33 // b LBB0_246 $-1844(%rip) +LBB0_340: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0d018c // add x12, x12, x13 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_341: + WORD $0x0a3b014c // bic w12, w10, w27 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f799b // bfi w27, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a1b014a // and w10, w10, w27 + WORD $0x1a9f37fb // cset w27, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a070147 // and x7, x10, x7 + WORD $0xb5ffcc67 // cbnz x7, LBB0_258 $-1652(%rip) +LBB0_342: + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_343: + WORD $0xb500097b // cbnz x27, LBB0_361 $300(%rip) + WORD $0xb40003da // cbz x26, LBB0_352 $120(%rip) +LBB0_345: + WORD $0xd280000a // mov x10, #0 +LBB0_346: + WORD $0x386a680c // ldrb w12, [x0, x10] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_351 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_349 $20(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xeb0a035f // cmp x26, x10 + WORD $0x54ffff21 // b.ne LBB0_346 $-28(%rip) + WORD $0x14000016 // b LBB0_353 $88(%rip) +LBB0_349: + WORD $0xd100074c // sub x12, x26, #1 + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x54001720 // b.eq LBB0_390 $740(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a018c // add x12, x12, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980198 // csel x24, x12, x24, eq + WORD $0x9a990199 // csel x25, x12, x25, eq + WORD $0x8b0a000c // add x12, x0, x10 + WORD $0x91000980 // add x0, x12, #2 + WORD $0xcb0a034c // sub x12, x26, x10 + WORD $0xd1000b4d // sub x13, x26, #2 + WORD $0xd100099a // sub x26, x12, #2 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54fffce1 // b.ne LBB0_345 $-100(%rip) + WORD $0x140000ab // b LBB0_390 $684(%rip) +LBB0_351: + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0x91000540 // add x0, x10, #1 +LBB0_352: + WORD $0xcb090000 // sub x0, x0, x9 + WORD $0x17fffbf1 // b LBB0_145 $-4156(%rip) +LBB0_353: + WORD $0x7100899f // cmp w12, #34 + WORD $0x540014a1 // b.ne LBB0_390 $660(%rip) + WORD $0x8b1a0000 // add x0, x0, x26 + WORD $0x17fffffb // b LBB0_352 $-20(%rip) +LBB0_355: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne +LBB0_356: + WORD $0x0a39014c // bic w12, w10, w25 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f7999 // bfi w25, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a19014a // and w10, w10, w25 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a1a015a // and x26, x10, x26 + WORD $0x17fffe4b // b LBB0_262 $-1748(%rip) +LBB0_357: + WORD $0xb40011fa // cbz x26, LBB0_390 $572(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x9a990159 // csel x25, x10, x25, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffee9a // cbnz x26, LBB0_328 $-560(%rip) + WORD $0x17ffff90 // b LBB0_335 $-448(%rip) +LBB0_359: + WORD $0xb40010ba // cbz x26, LBB0_390 $532(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffcafa // cbnz x26, LBB0_270 $-1700(%rip) + WORD $0x1400007d // b LBB0_390 $500(%rip) +LBB0_361: + WORD $0xb4000f9a // cbz x26, LBB0_390 $496(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x9a990159 // csel x25, x10, x25, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5fff5fa // cbnz x26, LBB0_345 $-324(%rip) + WORD $0x17ffffcb // b LBB0_352 $-212(%rip) +LBB0_363: + WORD $0xb4000e5a // cbz x26, LBB0_390 $456(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffccda // cbnz x26, LBB0_281 $-1640(%rip) + WORD $0x1400006a // b LBB0_390 $424(%rip) +LBB0_365: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0d018c // add x12, x12, x13 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_366: + WORD $0x0a3b014c // bic w12, w10, w27 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f799b // bfi w27, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a1b014a // and w10, w10, w27 + WORD $0x1a9f37fb // cset w27, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a070147 // and x7, x10, x7 + WORD $0xb5ffd247 // cbnz x7, LBB0_294 $-1464(%rip) +LBB0_367: + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa1303fa // mov x26, x19 +LBB0_368: + WORD $0xb500085b // cbnz x27, LBB0_384 $264(%rip) + WORD $0xb40003da // cbz x26, LBB0_377 $120(%rip) +LBB0_370: + WORD $0xd280000a // mov x10, #0 +LBB0_371: + WORD $0x386a680c // ldrb w12, [x0, x10] + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000300 // b.eq LBB0_376 $96(%rip) + WORD $0x7101719f // cmp w12, #92 + WORD $0x540000a0 // b.eq LBB0_374 $20(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xeb0a035f // cmp x26, x10 + WORD $0x54ffff21 // b.ne LBB0_371 $-28(%rip) + WORD $0x14000017 // b LBB0_378 $92(%rip) +LBB0_374: + WORD $0xd100074c // sub x12, x26, #1 + WORD $0xeb0a019f // cmp x12, x10 + WORD $0x540008a0 // b.eq LBB0_390 $276(%rip) + WORD $0xf9401bec // ldr x12, [sp, #48] + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x8b0a018c // add x12, x12, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980198 // csel x24, x12, x24, eq + WORD $0x9a990199 // csel x25, x12, x25, eq + WORD $0x8b0a000c // add x12, x0, x10 + WORD $0x91000980 // add x0, x12, #2 + WORD $0xcb0a034c // sub x12, x26, x10 + WORD $0xd1000b4d // sub x13, x26, #2 + WORD $0xd100099a // sub x26, x12, #2 + WORD $0xeb0a01bf // cmp x13, x10 + WORD $0x54fffce1 // b.ne LBB0_370 $-100(%rip) + WORD $0x14000037 // b LBB0_390 $220(%rip) +LBB0_376: + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0x91000540 // add x0, x10, #1 +LBB0_377: + WORD $0xcb090000 // sub x0, x0, x9 + WORD $0xb6ff5cc0 // tbz x0, #63, LBB0_117 $-5224(%rip) + WORD $0x14000030 // b LBB0_389 $192(%rip) +LBB0_378: + WORD $0x7100899f // cmp w12, #34 + WORD $0x54000601 // b.ne LBB0_390 $192(%rip) + WORD $0x8b1a0000 // add x0, x0, x26 + WORD $0x17fffffa // b LBB0_377 $-24(%rip) +LBB0_380: + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a8c1318 // csel x24, x24, x12, ne +LBB0_381: + WORD $0x0a39014c // bic w12, w10, w25 + WORD $0x531f798d // lsl w13, w12, #1 + WORD $0x331f7999 // bfi w25, w12, #1, #31 + WORD $0x0a2d014a // bic w10, w10, w13 + WORD $0x1201f14a // and w10, w10, #0xaaaaaaaa + WORD $0x2b0c014a // adds w10, w10, w12 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a19014a // and w10, w10, w25 + WORD $0x1a9f37f9 // cset w25, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a1a015a // and x26, x10, x26 + WORD $0x17fffe7a // b LBB0_298 $-1560(%rip) +LBB0_382: + WORD $0xb400035a // cbz x26, LBB0_390 $104(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100071f // cmn x24, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5ffd3ba // cbnz x26, LBB0_309 $-1420(%rip) + WORD $0x14000012 // b LBB0_390 $72(%rip) +LBB0_384: + WORD $0xb400023a // cbz x26, LBB0_390 $68(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb100073f // cmn x25, #1 + WORD $0x9a980158 // csel x24, x10, x24, eq + WORD $0x9a990159 // csel x25, x10, x25, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd100075a // sub x26, x26, #1 + WORD $0xb5fff71a // cbnz x26, LBB0_370 $-288(%rip) + WORD $0x17ffffd4 // b LBB0_377 $-176(%rip) +LBB0_386: + WORD $0xf9000028 // str x8, [x1] +LBB0_387: + WORD $0x9280000f // mov x15, #-1 + WORD $0x1400001a // b LBB0_400 $104(%rip) +LBB0_388: + WORD $0x928000cf // mov x15, #-7 + WORD $0x14000018 // b LBB0_400 $96(%rip) +LBB0_389: + WORD $0xb100041f // cmn x0, #1 + WORD $0x54000281 // b.ne LBB0_399 $80(%rip) +LBB0_390: + WORD $0x92800000 // mov x0, #-1 + WORD $0xaa0f03f8 // mov x24, x15 + WORD $0x14000011 // b LBB0_399 $68(%rip) +LBB0_391: + WORD $0x92800013 // mov x19, #-1 +LBB0_392: + WORD $0xaa3303e9 // mvn x9, x19 + WORD $0x8b090108 // add x8, x8, x9 +LBB0_393: + WORD $0xf9000028 // str x8, [x1] +LBB0_394: + WORD $0x9280002f // mov x15, #-2 + WORD $0x1400000d // b LBB0_400 $52(%rip) +LBB0_395: + WORD $0xb100071f // cmn x24, #1 + WORD $0x540000a0 // b.eq LBB0_398 $20(%rip) + WORD $0x92800020 // mov x0, #-2 + WORD $0x14000007 // b LBB0_399 $28(%rip) +LBB0_397: + WORD $0xf900002a // str x10, [x1] + WORD $0x17ffffec // b LBB0_387 $-80(%rip) +LBB0_398: + WORD $0xdac00148 // rbit x8, x10 + WORD $0xdac01108 // clz x8, x8 + WORD $0x8b000118 // add x24, x8, x0 + WORD $0x92800020 // mov x0, #-2 +LBB0_399: + WORD $0xf9000038 // str x24, [x1] + WORD $0xaa0003ef // mov x15, x0 +LBB0_400: + WORD $0xaa0f03e0 // mov x0, x15 + WORD $0xa9497bfd // ldp x29, x30, [sp, #144] + WORD $0xa9484ff4 // ldp x20, x19, [sp, #128] + WORD $0xa94757f6 // ldp x22, x21, [sp, #112] + WORD $0xa9465ff8 // ldp x24, x23, [sp, #96] + WORD $0xa94567fa // ldp x26, x25, [sp, #80] + WORD $0xa9446ffc // ldp x28, x27, [sp, #64] + WORD $0x910283ff // add sp, sp, #160 + WORD $0xd65f03c0 // ret +LBB0_401: + WORD $0x9280001b // mov x27, #-1 +LBB0_402: + WORD $0xcb1b0108 // sub x8, x8, x27 + WORD $0x17ffffe6 // b LBB0_393 $-104(%rip) +LBB0_403: + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x7101855f // cmp w10, #97 + WORD $0x54fffc81 // b.ne LBB0_394 $-112(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101b15f // cmp w10, #108 + WORD $0x54fffbe1 // b.ne LBB0_394 $-132(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101cd5f // cmp w10, #115 + WORD $0x54fffb41 // b.ne LBB0_394 $-152(%rip) + WORD $0x9100110a // add x10, x8, #4 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101953f // cmp w9, #101 + WORD $0x54fffaa1 // b.ne LBB0_394 $-172(%rip) + WORD $0x91001508 // add x8, x8, #5 + WORD $0x17ffffd2 // b LBB0_393 $-184(%rip) +LBB0_408: + WORD $0xf9000028 // str x8, [x1] + WORD $0x3940030a // ldrb w10, [x24] + WORD $0x7101b95f // cmp w10, #110 + WORD $0x54fff9e1 // b.ne LBB0_394 $-196(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101d55f // cmp w10, #117 + WORD $0x54fff941 // b.ne LBB0_394 $-216(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101b15f // cmp w10, #108 + WORD $0x54fff8a1 // b.ne LBB0_394 $-236(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101b13f // cmp w9, #108 + WORD $0x54fff801 // b.ne LBB0_394 $-256(%rip) + WORD $0x14000014 // b LBB0_416 $80(%rip) +LBB0_412: + WORD $0xf9000028 // str x8, [x1] + WORD $0x3940030a // ldrb w10, [x24] + WORD $0x7101d15f // cmp w10, #116 + WORD $0x54fff761 // b.ne LBB0_394 $-276(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101c95f // cmp w10, #114 + WORD $0x54fff6c1 // b.ne LBB0_394 $-296(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101d55f // cmp w10, #117 + WORD $0x54fff621 // b.ne LBB0_394 $-316(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101953f // cmp w9, #101 + WORD $0x54fff581 // b.ne LBB0_394 $-336(%rip) +LBB0_416: + WORD $0x91001108 // add x8, x8, #4 + WORD $0x17ffffa9 // b LBB0_393 $-348(%rip) +LBB0_417: + WORD $0xaa0003ef // mov x15, x0 + WORD $0x17ffffa1 // b LBB0_390 $-380(%rip) +LBB0_418: + WORD $0x8b000158 // add x24, x10, x0 + WORD $0x92800020 // mov x0, #-2 + WORD $0x17ffffb1 // b LBB0_399 $-316(%rip) +LBB0_419: + WORD $0xcb090008 // sub x8, x0, x9 + WORD $0x8b0a0118 // add x24, x8, x10 + WORD $0x92800020 // mov x0, #-2 + WORD $0x17ffffad // b LBB0_399 $-332(%rip) +LBB0_420: + WORD $0xcb090018 // sub x24, x0, x9 + WORD $0x92800020 // mov x0, #-2 + WORD $0x17ffffaa // b LBB0_399 $-344(%rip) + // .p2align 1, 0x00 +LJTI0_0: + WORD $0x00050000 + WORD $0x006d000e + WORD $0x01070071 + // // .word (LBB0_32-LBB0_32)>>2 +// .word (LBB0_34-LBB0_32)>>2 +// .word (LBB0_37-LBB0_32)>>2 +// .word (LBB0_49-LBB0_32)>>2 +// .word (LBB0_51-LBB0_32)>>2 +// .word (LBB0_87-LBB0_32)>>2 + +LJTI0_1: + WORD $0x06c006ce + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c00213 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x027006c0 + WORD $0x06c006c0 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x027b06c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c00283 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c0028e + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x06c00298 + WORD $0x06c006c0 + WORD $0x06c006c0 + WORD $0x02a306c0 + // // .word (LBB0_400-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_151-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_162-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_56-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_166-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_168-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_171-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_173-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_394-LBB0_56)>>2 +// .word (LBB0_176-LBB0_56)>>2 + +LJTI0_2: + WORD $0x12001e00 + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x1e1e1e1e + WORD $0x00181e1e + // // .byte (LBB0_212-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_212-LBB0_212)>>2 +// .byte (LBB0_218-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_224-LBB0_212)>>2 +// .byte (LBB0_221-LBB0_212)>>2 + +LJTI0_3: + WORD $0x01070013 + WORD $0x00170013 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x01070107 + WORD $0x00000000 + // // .word (LBB0_85-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_85-LBB0_80)>>2 +// .word (LBB0_86-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_119-LBB0_80)>>2 +// .word (LBB0_80-LBB0_80)>>2 + +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__skip_one(SB), $0-40 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $192, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_skip_one: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + MOVD m+16(FP), R2 + MOVD flags+24(FP), R3 + CALL ·__skip_one_arm64_entry__+76(SB) // _skip_one + MOVD R0, ret+32(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/skip_one_fast_arm64.go b/internal/native/neon/skip_one_fast_arm64.go new file mode 100644 index 000000000..0e3a995fa --- /dev/null +++ b/internal/native/neon/skip_one_fast_arm64.go @@ -0,0 +1,31 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +//go:nosplit +func skip_one_fast(s *string, p *int) (ret int) { + return __skip_one_fast(s, p) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __skip_one_fast(s *string, p *int) (ret int) diff --git a/internal/native/neon/skip_one_fast_arm64.s b/internal/native/neon/skip_one_fast_arm64.s new file mode 100644 index 000000000..8b81ed559 --- /dev/null +++ b/internal/native/neon/skip_one_fast_arm64.s @@ -0,0 +1,1184 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__skip_one_fast_arm64_entry__(SB), NOSPLIT, $128 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910243ff // add sp, sp, #144 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_1: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_skip_one_fast: + MOVD.W R30, -144(RSP) // WORD $0xf8170ffe // str x30, [sp, #-144]! + WORD $0xa9065ff8 // stp x24, x23, [sp, #96] + WORD $0xa90757f6 // stp x22, x21, [sp, #112] + WORD $0xa9084ff4 // stp x20, x19, [sp, #128] + WORD $0xa940200c // ldp x12, x8, [x0] + WORD $0xf940002a // ldr x10, [x1] + WORD $0xeb08015f // cmp x10, x8 + WORD $0x54000142 // b.hs LBB0_4 $40(%rip) + WORD $0x386a6989 // ldrb w9, [x12, x10] + WORD $0x7100353f // cmp w9, #13 + WORD $0x540000e0 // b.eq LBB0_4 $28(%rip) + WORD $0x7100813f // cmp w9, #32 + WORD $0x540000a0 // b.eq LBB0_4 $20(%rip) + WORD $0x51002d2b // sub w11, w9, #11 + WORD $0xaa0a03e9 // mov x9, x10 + WORD $0x3100097f // cmn w11, #2 + WORD $0x54000803 // b.lo LBB0_26 $256(%rip) +LBB0_4: + WORD $0x91000549 // add x9, x10, #1 + WORD $0xeb08013f // cmp x9, x8 + WORD $0x54000122 // b.hs LBB0_8 $36(%rip) + WORD $0x3869698b // ldrb w11, [x12, x9] + WORD $0x7100357f // cmp w11, #13 + WORD $0x540000c0 // b.eq LBB0_8 $24(%rip) + WORD $0x7100817f // cmp w11, #32 + WORD $0x54000080 // b.eq LBB0_8 $16(%rip) + WORD $0x51002d6b // sub w11, w11, #11 + WORD $0x3100097f // cmn w11, #2 + WORD $0x540006a3 // b.lo LBB0_26 $212(%rip) +LBB0_8: + WORD $0x91000949 // add x9, x10, #2 + WORD $0xeb08013f // cmp x9, x8 + WORD $0x54000122 // b.hs LBB0_12 $36(%rip) + WORD $0x3869698b // ldrb w11, [x12, x9] + WORD $0x7100357f // cmp w11, #13 + WORD $0x540000c0 // b.eq LBB0_12 $24(%rip) + WORD $0x7100817f // cmp w11, #32 + WORD $0x54000080 // b.eq LBB0_12 $16(%rip) + WORD $0x51002d6b // sub w11, w11, #11 + WORD $0x3100097f // cmn w11, #2 + WORD $0x54000543 // b.lo LBB0_26 $168(%rip) +LBB0_12: + WORD $0x91000d49 // add x9, x10, #3 + WORD $0xeb08013f // cmp x9, x8 + WORD $0x54000122 // b.hs LBB0_16 $36(%rip) + WORD $0x3869698b // ldrb w11, [x12, x9] + WORD $0x7100357f // cmp w11, #13 + WORD $0x540000c0 // b.eq LBB0_16 $24(%rip) + WORD $0x7100817f // cmp w11, #32 + WORD $0x54000080 // b.eq LBB0_16 $16(%rip) + WORD $0x51002d6b // sub w11, w11, #11 + WORD $0x3100097f // cmn w11, #2 + WORD $0x540003e3 // b.lo LBB0_26 $124(%rip) +LBB0_16: + WORD $0x91001149 // add x9, x10, #4 + WORD $0xeb09011f // cmp x8, x9 + WORD $0x54000209 // b.ls LBB0_21 $64(%rip) + WORD $0x540002e0 // b.eq LBB0_23 $92(%rip) + WORD $0x8b08018a // add x10, x12, x8 + WORD $0x5280002b // mov w11, #1 + WORD $0xd284c00d // mov x13, #9728 + WORD $0xf2c0002d // movk x13, #1, lsl #32 +LBB0_19: + WORD $0x38e9698e // ldrsb w14, [x12, x9] + WORD $0x710081df // cmp w14, #32 + WORD $0x9ace216e // lsl x14, x11, x14 + WORD $0x8a0d01ce // and x14, x14, x13 + WORD $0xfa4099c4 // ccmp x14, #0, #4, ls + WORD $0x540001e0 // b.eq LBB0_25 $60(%rip) + WORD $0x91000529 // add x9, x9, #1 + WORD $0xeb09011f // cmp x8, x9 + WORD $0x54ffff01 // b.ne LBB0_19 $-32(%rip) + WORD $0x1400000a // b LBB0_24 $40(%rip) +LBB0_21: + WORD $0xf9000029 // str x9, [x1] + WORD $0x92800008 // mov x8, #-1 +LBB0_22: + WORD $0xaa0803e0 // mov x0, x8 + WORD $0xa9484ff4 // ldp x20, x19, [sp, #128] + WORD $0xa94757f6 // ldp x22, x21, [sp, #112] + WORD $0xa9465ff8 // ldp x24, x23, [sp, #96] + WORD $0x910243ff // add sp, sp, #144 + WORD $0xd65f03c0 // ret +LBB0_23: + WORD $0x8b09018a // add x10, x12, x9 +LBB0_24: + WORD $0xcb0c0149 // sub x9, x10, x12 +LBB0_25: + WORD $0xeb08013f // cmp x9, x8 + WORD $0x540033c2 // b.hs LBB0_81 $1656(%rip) +LBB0_26: + WORD $0x9100052d // add x13, x9, #1 + WORD $0xf900002d // str x13, [x1] + WORD $0x38e9698a // ldrsb w10, [x12, x9] + WORD $0x7101ed5f // cmp w10, #123 + WORD $0x54000868 // b.hi LBB0_44 $268(%rip) + WORD $0x92800008 // mov x8, #-1 +Lloh0: + WORD $0x10005beb // adr x11, LJTI0_0 $2940(%rip) +Lloh1: + WORD $0x9100016b // add x11, x11, LJTI0_0@PAGEOFF $0(%rip) + WORD $0x10fffdce // adr x14, LBB0_22 $-72(%rip) + WORD $0x786a796f // ldrh w15, [x11, x10, lsl #1] + WORD $0x8b0f09ce // add x14, x14, x15, lsl #2 + WORD $0xd61f01c0 // br x14 +LBB0_28: + WORD $0xf9400408 // ldr x8, [x0, #8] + WORD $0xcb0d0108 // sub x8, x8, x13 + WORD $0xf100411f // cmp x8, #16 + WORD $0x540002c3 // b.lo LBB0_32 $88(%rip) + WORD $0x4f01e580 // movi.16b v0, #44 + WORD $0x4f06e7e1 // movi.16b v1, #223 + WORD $0x4f02e7a2 // movi.16b v2, #93 +Lloh2: + WORD $0x10fff2aa // adr x10, lCPI0_0 $-428(%rip) +Lloh3: + WORD $0x3dc00143 // ldr q3, [x10, lCPI0_0@PAGEOFF] $0(%rip) +Lloh4: + WORD $0x10fff2ea // adr x10, lCPI0_1 $-420(%rip) +Lloh5: + WORD $0x3dc00144 // ldr q4, [x10, lCPI0_1@PAGEOFF] $0(%rip) +LBB0_30: + WORD $0x3ced6985 // ldr q5, [x12, x13] + WORD $0x6e208ca6 // cmeq.16b v6, v5, v0 + WORD $0x4e211ca5 // and.16b v5, v5, v1 + WORD $0x6e228ca5 // cmeq.16b v5, v5, v2 + WORD $0x4ea61ca5 // orr.16b v5, v5, v6 + WORD $0x4e231ca5 // and.16b v5, v5, v3 + WORD $0x4e0400a5 // tbl.16b v5, { v5 }, v4 + WORD $0x4e71b8a5 // addv.8h h5, v5 + WORD $0x1e2600aa // fmov w10, s5 + WORD $0x350002ea // cbnz w10, LBB0_40 $92(%rip) + WORD $0xd1004108 // sub x8, x8, #16 + WORD $0x910041ad // add x13, x13, #16 + WORD $0xf1003d1f // cmp x8, #15 + WORD $0x54fffe68 // b.hi LBB0_30 $-52(%rip) +LBB0_32: + WORD $0x8b0d018a // add x10, x12, x13 + WORD $0xb40001e8 // cbz x8, LBB0_39 $60(%rip) + WORD $0x8b08014d // add x13, x10, x8 + WORD $0xcb0c014b // sub x11, x10, x12 +LBB0_34: + WORD $0x3940014e // ldrb w14, [x10] + WORD $0x7100b1df // cmp w14, #44 + WORD $0x540001e0 // b.eq LBB0_41 $60(%rip) + WORD $0x7101f5df // cmp w14, #125 + WORD $0x540001a0 // b.eq LBB0_41 $52(%rip) + WORD $0x710175df // cmp w14, #93 + WORD $0x54000160 // b.eq LBB0_41 $44(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0x9100056b // add x11, x11, #1 + WORD $0xf1000508 // subs x8, x8, #1 + WORD $0x54fffec1 // b.ne LBB0_34 $-40(%rip) + WORD $0xaa0d03ea // mov x10, x13 +LBB0_39: + WORD $0xcb0c014b // sub x11, x10, x12 + WORD $0x14000004 // b LBB0_41 $16(%rip) +LBB0_40: + WORD $0x5ac00148 // rbit w8, w10 + WORD $0x5ac01108 // clz w8, w8 + WORD $0x8b0d010b // add x11, x8, x13 +LBB0_41: + WORD $0xf900002b // str x11, [x1] +LBB0_42: + WORD $0xaa0903e8 // mov x8, x9 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0xa9484ff4 // ldp x20, x19, [sp, #128] + WORD $0xa94757f6 // ldp x22, x21, [sp, #112] + WORD $0xa9465ff8 // ldp x24, x23, [sp, #96] + WORD $0x910243ff // add sp, sp, #144 + WORD $0xd65f03c0 // ret +LBB0_43: + WORD $0x91001128 // add x8, x9, #4 + WORD $0xf940040a // ldr x10, [x0, #8] + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x54002b08 // b.hi LBB0_81 $1376(%rip) + WORD $0x14000278 // b LBB0_109 $2528(%rip) +LBB0_44: + WORD $0xf9000029 // str x9, [x1] + WORD $0x92800028 // mov x8, #-2 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0xa9484ff4 // ldp x20, x19, [sp, #128] + WORD $0xa94757f6 // ldp x22, x21, [sp, #112] + WORD $0xa9465ff8 // ldp x24, x23, [sp, #96] + WORD $0x910243ff // add sp, sp, #144 + WORD $0xd65f03c0 // ret +LBB0_45: + WORD $0xf940040e // ldr x14, [x0, #8] + WORD $0xcb0d01ca // sub x10, x14, x13 + WORD $0xf100815f // cmp x10, #32 + WORD $0x540050ab // b.lt LBB0_115 $2580(%rip) + WORD $0xd2800008 // mov x8, #0 + WORD $0xd280000d // mov x13, #0 + WORD $0x8b09018b // add x11, x12, x9 + WORD $0x4f01e440 // movi.16b v0, #34 +Lloh6: + WORD $0x10ffea2a // adr x10, lCPI0_0 $-700(%rip) +Lloh7: + WORD $0x3dc00141 // ldr q1, [x10, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0xcb0901ca // sub x10, x14, x9 +Lloh8: + WORD $0x10ffea4e // adr x14, lCPI0_1 $-696(%rip) +Lloh9: + WORD $0x3dc001c2 // ldr q2, [x14, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x528003ee // mov w14, #31 + WORD $0x4f02e783 // movi.16b v3, #92 +LBB0_47: + WORD $0x8b08016f // add x15, x11, x8 + WORD $0x3cc011e4 // ldur q4, [x15, #1] + WORD $0x3cc111e5 // ldur q5, [x15, #17] + WORD $0x6e208c86 // cmeq.16b v6, v4, v0 + WORD $0x4e211cc6 // and.16b v6, v6, v1 + WORD $0x4e0200c6 // tbl.16b v6, { v6 }, v2 + WORD $0x4e71b8c6 // addv.8h h6, v6 + WORD $0x1e2600cf // fmov w15, s6 + WORD $0x6e208ca6 // cmeq.16b v6, v5, v0 + WORD $0x4e211cc6 // and.16b v6, v6, v1 + WORD $0x4e0200c6 // tbl.16b v6, { v6 }, v2 + WORD $0x4e71b8c6 // addv.8h h6, v6 + WORD $0x1e2600d0 // fmov w16, s6 + WORD $0x33103e0f // bfi w15, w16, #16, #16 + WORD $0x6e238c84 // cmeq.16b v4, v4, v3 + WORD $0x4e211c84 // and.16b v4, v4, v1 + WORD $0x4e020084 // tbl.16b v4, { v4 }, v2 + WORD $0x4e71b884 // addv.8h h4, v4 + WORD $0x1e260090 // fmov w16, s4 + WORD $0x6e238ca4 // cmeq.16b v4, v5, v3 + WORD $0x4e211c84 // and.16b v4, v4, v1 + WORD $0x4e020084 // tbl.16b v4, { v4 }, v2 + WORD $0x4e71b884 // addv.8h h4, v4 + WORD $0x1e260091 // fmov w17, s4 + WORD $0x33103e30 // bfi w16, w17, #16, #16 + WORD $0x7100021f // cmp w16, #0 + WORD $0xfa4009a0 // ccmp x13, #0, #0, eq + WORD $0x540001a0 // b.eq LBB0_49 $52(%rip) + WORD $0x0a2d0211 // bic w17, w16, w13 + WORD $0x2a1105a0 // orr w0, w13, w17, lsl #1 + WORD $0x0a20020d // bic w13, w16, w0 + WORD $0x1201f1ad // and w13, w13, #0xaaaaaaaa + WORD $0x2b1101b0 // adds w16, w13, w17 + WORD $0x1a9f37ed // cset w13, hs + WORD $0x531f7a10 // lsl w16, w16, #1 + WORD $0x5200f210 // eor w16, w16, #0x55555555 + WORD $0x0a000210 // and w16, w16, w0 + WORD $0x2a3003f0 // mvn w16, w16 + WORD $0x8a0f020f // and x15, x16, x15 + WORD $0x14000002 // b LBB0_50 $8(%rip) +LBB0_49: + WORD $0xd280000d // mov x13, #0 +LBB0_50: + WORD $0x3500464f // cbnz w15, LBB0_108 $2248(%rip) + WORD $0x91008108 // add x8, x8, #32 + WORD $0xd10081ce // sub x14, x14, #32 + WORD $0x8b0e014f // add x15, x10, x14 + WORD $0xf100fdff // cmp x15, #63 + WORD $0x54fffa4c // b.gt LBB0_47 $-184(%rip) + WORD $0xb50049ed // cbnz x13, LBB0_117 $2364(%rip) + WORD $0x8b09018b // add x11, x12, x9 + WORD $0x8b08016b // add x11, x11, x8 + WORD $0x9100056b // add x11, x11, #1 + WORD $0xaa2803e8 // mvn x8, x8 + WORD $0x8b0a010a // add x10, x8, x10 +LBB0_54: + WORD $0xf100055f // cmp x10, #1 + WORD $0x5400466a // b.ge LBB0_111 $2252(%rip) + WORD $0x14000108 // b LBB0_81 $1056(%rip) +LBB0_55: + WORD $0xd2800004 // mov x4, #0 + WORD $0xd280000b // mov x11, #0 + WORD $0xd2800008 // mov x8, #0 + WORD $0xd280000a // mov x10, #0 + WORD $0xf940040e // ldr x14, [x0, #8] + WORD $0xcb0d01c2 // sub x2, x14, x13 + WORD $0x8b0d018d // add x13, x12, x13 + WORD $0x910083ec // add x12, sp, #32 + WORD $0x9100818c // add x12, x12, #32 + WORD $0x4f01e440 // movi.16b v0, #34 +Lloh10: + WORD $0x10ffe10e // adr x14, lCPI0_0 $-992(%rip) +Lloh11: + WORD $0x3dc001c1 // ldr q1, [x14, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x4f02e782 // movi.16b v2, #92 +Lloh12: + WORD $0x10ffe12e // adr x14, lCPI0_1 $-988(%rip) +Lloh13: + WORD $0x3dc001c3 // ldr q3, [x14, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0xb200e3ee // mov x14, #1229782938247303441 + WORD $0xb201e3ef // mov x15, #-8608480567731124088 + WORD $0xb202e3f0 // mov x16, #4919131752989213764 + WORD $0xb203e3f1 // mov x17, #2459565876494606882 + WORD $0x4f02e764 // movi.16b v4, #91 + WORD $0x4f02e7a5 // movi.16b v5, #93 + WORD $0x6f00e406 // movi.2d v6, #0000000000000000 + WORD $0x14000009 // b LBB0_57 $36(%rip) +LBB0_56: + WORD $0x937ffc84 // asr x4, x4, #63 + WORD $0x9e6700a7 // fmov d7, x5 + WORD $0x0e2058e7 // cnt.8b v7, v7 + WORD $0x2e3038e7 // uaddlv.8b h7, v7 + WORD $0x1e2600e2 // fmov w2, s7 + WORD $0x8b080048 // add x8, x2, x8 + WORD $0x910101ad // add x13, x13, #64 + WORD $0xaa0303e2 // mov x2, x3 +LBB0_57: + WORD $0xf1010043 // subs x3, x2, #64 + WORD $0x540015eb // b.lt LBB0_64 $700(%rip) +LBB0_58: + WORD $0xad4045b2 // ldp q18, q17, [x13] + WORD $0xad411db0 // ldp q16, q7, [x13, #32] + WORD $0x6e228e53 // cmeq.16b v19, v18, v2 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260265 // fmov w5, s19 + WORD $0x6e228e33 // cmeq.16b v19, v17, v2 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260266 // fmov w6, s19 + WORD $0x6e228e13 // cmeq.16b v19, v16, v2 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260267 // fmov w7, s19 + WORD $0x6e228cf3 // cmeq.16b v19, v7, v2 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260273 // fmov w19, s19 + WORD $0xd3607ce7 // lsl x7, x7, #32 + WORD $0xb3503e67 // bfi x7, x19, #48, #16 + WORD $0x53103cc6 // lsl w6, w6, #16 + WORD $0xaa0600e6 // orr x6, x7, x6 + WORD $0xaa0500c5 // orr x5, x6, x5 + WORD $0xaa0b00a6 // orr x6, x5, x11 + WORD $0xb5000086 // cbnz x6, LBB0_60 $16(%rip) + WORD $0xd280000b // mov x11, #0 + WORD $0x92800005 // mov x5, #-1 + WORD $0x1400000b // b LBB0_61 $44(%rip) +LBB0_60: + WORD $0x8a2b00a6 // bic x6, x5, x11 + WORD $0xaa060567 // orr x7, x11, x6, lsl #1 + WORD $0x8a2700ab // bic x11, x5, x7 + WORD $0x9201f16b // and x11, x11, #0xaaaaaaaaaaaaaaaa + WORD $0xab060165 // adds x5, x11, x6 + WORD $0x1a9f37eb // cset w11, hs + WORD $0xd37ff8a5 // lsl x5, x5, #1 + WORD $0xd200f0a5 // eor x5, x5, #0x5555555555555555 + WORD $0x8a0700a5 // and x5, x5, x7 + WORD $0xaa2503e5 // mvn x5, x5 +LBB0_61: + WORD $0x6e208e53 // cmeq.16b v19, v18, v0 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x6e208e34 // cmeq.16b v20, v17, v0 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x6e208e15 // cmeq.16b v21, v16, v0 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x6e208cf6 // cmeq.16b v22, v7, v0 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c6 // fmov w6, s22 + WORD $0xd3503cc6 // lsl x6, x6, #48 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602a7 // fmov w7, s21 + WORD $0xb3603ce6 // bfi x6, x7, #32, #16 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x53103ce7 // lsl w7, w7, #16 + WORD $0xaa0700c6 // orr x6, x6, x7 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260267 // fmov w7, s19 + WORD $0xaa0700c6 // orr x6, x6, x7 + WORD $0x8a0500c5 // and x5, x6, x5 + WORD $0x9200e0a6 // and x6, x5, #0x1111111111111111 + WORD $0x9203e0a7 // and x7, x5, #0x2222222222222222 + WORD $0x9202e0b3 // and x19, x5, #0x4444444444444444 + WORD $0x9201e0a5 // and x5, x5, #0x8888888888888888 + WORD $0x9b0e7cd4 // mul x20, x6, x14 + WORD $0x9b0f7cf5 // mul x21, x7, x15 + WORD $0xca150294 // eor x20, x20, x21 + WORD $0x9b107e75 // mul x21, x19, x16 + WORD $0xca150294 // eor x20, x20, x21 + WORD $0x9b117cb5 // mul x21, x5, x17 + WORD $0xca150294 // eor x20, x20, x21 + WORD $0x9b117cd5 // mul x21, x6, x17 + WORD $0x9b0e7cf6 // mul x22, x7, x14 + WORD $0xca1602b5 // eor x21, x21, x22 + WORD $0x9b0f7e76 // mul x22, x19, x15 + WORD $0xca1602b5 // eor x21, x21, x22 + WORD $0x9b107cb6 // mul x22, x5, x16 + WORD $0xca1602b5 // eor x21, x21, x22 + WORD $0x9b107cd6 // mul x22, x6, x16 + WORD $0x9b117cf7 // mul x23, x7, x17 + WORD $0xca1702d6 // eor x22, x22, x23 + WORD $0x9b0e7e77 // mul x23, x19, x14 + WORD $0xca1702d6 // eor x22, x22, x23 + WORD $0x9b0f7cb7 // mul x23, x5, x15 + WORD $0xca1702d6 // eor x22, x22, x23 + WORD $0x9b0f7cc6 // mul x6, x6, x15 + WORD $0x9b107ce7 // mul x7, x7, x16 + WORD $0xca0700c6 // eor x6, x6, x7 + WORD $0x9b117e67 // mul x7, x19, x17 + WORD $0xca0700c6 // eor x6, x6, x7 + WORD $0x9b0e7ca5 // mul x5, x5, x14 + WORD $0xca0500c5 // eor x5, x6, x5 + WORD $0x9200e286 // and x6, x20, #0x1111111111111111 + WORD $0x9203e2a7 // and x7, x21, #0x2222222222222222 + WORD $0x9202e2d3 // and x19, x22, #0x4444444444444444 + WORD $0x9201e0a5 // and x5, x5, #0x8888888888888888 + WORD $0xaa0700c6 // orr x6, x6, x7 + WORD $0xaa1300c6 // orr x6, x6, x19 + WORD $0xaa0500c5 // orr x5, x6, x5 + WORD $0xca0400a4 // eor x4, x5, x4 + WORD $0x6e248e53 // cmeq.16b v19, v18, v4 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260265 // fmov w5, s19 + WORD $0x6e248e33 // cmeq.16b v19, v17, v4 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260266 // fmov w6, s19 + WORD $0x6e248e13 // cmeq.16b v19, v16, v4 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260267 // fmov w7, s19 + WORD $0x6e248cf3 // cmeq.16b v19, v7, v4 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260273 // fmov w19, s19 + WORD $0xd3607ce7 // lsl x7, x7, #32 + WORD $0xb3503e67 // bfi x7, x19, #48, #16 + WORD $0x53103cc6 // lsl w6, w6, #16 + WORD $0xaa0600e6 // orr x6, x7, x6 + WORD $0xaa0500c5 // orr x5, x6, x5 + WORD $0x8a2400a5 // bic x5, x5, x4 + WORD $0x6e258e52 // cmeq.16b v18, v18, v5 + WORD $0x4e211e52 // and.16b v18, v18, v1 + WORD $0x4e030252 // tbl.16b v18, { v18 }, v3 + WORD $0x4e71ba52 // addv.8h h18, v18 + WORD $0x1e260246 // fmov w6, s18 + WORD $0x6e258e31 // cmeq.16b v17, v17, v5 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e030231 // tbl.16b v17, { v17 }, v3 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260227 // fmov w7, s17 + WORD $0x6e258e10 // cmeq.16b v16, v16, v5 + WORD $0x4e211e10 // and.16b v16, v16, v1 + WORD $0x4e030210 // tbl.16b v16, { v16 }, v3 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e260213 // fmov w19, s16 + WORD $0x6e258ce7 // cmeq.16b v7, v7, v5 + WORD $0x4e211ce7 // and.16b v7, v7, v1 + WORD $0x4e0300e7 // tbl.16b v7, { v7 }, v3 + WORD $0x4e71b8e7 // addv.8h h7, v7 + WORD $0x1e2600f4 // fmov w20, s7 + WORD $0xd3607e73 // lsl x19, x19, #32 + WORD $0xb3503e93 // bfi x19, x20, #48, #16 + WORD $0x53103ce7 // lsl w7, w7, #16 + WORD $0xaa070267 // orr x7, x19, x7 + WORD $0xaa0600e6 // orr x6, x7, x6 + WORD $0xea2400c6 // bics x6, x6, x4 + WORD $0x54ffeac0 // b.eq LBB0_56 $-680(%rip) +LBB0_62: + WORD $0xd10004c7 // sub x7, x6, #1 + WORD $0x8a0500f3 // and x19, x7, x5 + WORD $0x9e670267 // fmov d7, x19 + WORD $0x0e2058e7 // cnt.8b v7, v7 + WORD $0x2e3038e7 // uaddlv.8b h7, v7 + WORD $0x1e2600f3 // fmov w19, s7 + WORD $0x8b080273 // add x19, x19, x8 + WORD $0xeb0a027f // cmp x19, x10 + WORD $0x540028e9 // b.ls LBB0_107 $1308(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xea0600e6 // ands x6, x7, x6 + WORD $0x54fffea1 // b.ne LBB0_62 $-44(%rip) + WORD $0x17ffff49 // b LBB0_56 $-732(%rip) +LBB0_64: + WORD $0xf100005f // cmp x2, #0 + WORD $0x54002e6d // b.le LBB0_116 $1484(%rip) + WORD $0xad021be6 // stp q6, q6, [sp, #64] + WORD $0xad011be6 // stp q6, q6, [sp, #32] + WORD $0x92402da5 // and x5, x13, #0xfff + WORD $0xf13f04bf // cmp x5, #4033 + WORD $0x54ffe983 // b.lo LBB0_58 $-720(%rip) + WORD $0xf1008046 // subs x6, x2, #32 + WORD $0x54000103 // b.lo LBB0_68 $32(%rip) + WORD $0x3dc001a7 // ldr q7, [x13] + WORD $0x3d800be7 // str q7, [sp, #32] + WORD $0x3dc005a7 // ldr q7, [x13, #16] + WORD $0x3d800fe7 // str q7, [sp, #48] + WORD $0x910081ad // add x13, x13, #32 + WORD $0xaa0c03e5 // mov x5, x12 + WORD $0x14000003 // b LBB0_69 $12(%rip) +LBB0_68: + WORD $0x910083e5 // add x5, sp, #32 + WORD $0xaa0203e6 // mov x6, x2 +LBB0_69: + WORD $0xf10040c7 // subs x7, x6, #16 + WORD $0x54000243 // b.lo LBB0_75 $72(%rip) + WORD $0x3cc105a7 // ldr q7, [x13], #16 + WORD $0x3c8104a7 // str q7, [x5], #16 + WORD $0xaa0703e6 // mov x6, x7 + WORD $0xf10020c7 // subs x7, x6, #8 + WORD $0x540001e2 // b.hs LBB0_76 $60(%rip) +LBB0_71: + WORD $0xf10010c7 // subs x7, x6, #4 + WORD $0x54000243 // b.lo LBB0_77 $72(%rip) +LBB0_72: + WORD $0xb84045a6 // ldr w6, [x13], #4 + WORD $0xb80044a6 // str w6, [x5], #4 + WORD $0xaa0703e6 // mov x6, x7 + WORD $0xf10008c7 // subs x7, x6, #2 + WORD $0x540001e2 // b.hs LBB0_78 $60(%rip) +LBB0_73: + WORD $0xb4000246 // cbz x6, LBB0_79 $72(%rip) +LBB0_74: + WORD $0x394001ad // ldrb w13, [x13] + WORD $0x390000ad // strb w13, [x5] + WORD $0x910083ed // add x13, sp, #32 + WORD $0x17ffff2e // b LBB0_58 $-840(%rip) +LBB0_75: + WORD $0xf10020c7 // subs x7, x6, #8 + WORD $0x54fffe63 // b.lo LBB0_71 $-52(%rip) +LBB0_76: + WORD $0xf84085a6 // ldr x6, [x13], #8 + WORD $0xf80084a6 // str x6, [x5], #8 + WORD $0xaa0703e6 // mov x6, x7 + WORD $0xf10010c7 // subs x7, x6, #4 + WORD $0x54fffe02 // b.hs LBB0_72 $-64(%rip) +LBB0_77: + WORD $0xf10008c7 // subs x7, x6, #2 + WORD $0x54fffe63 // b.lo LBB0_73 $-52(%rip) +LBB0_78: + WORD $0x784025a6 // ldrh w6, [x13], #2 + WORD $0x780024a6 // strh w6, [x5], #2 + WORD $0xaa0703e6 // mov x6, x7 + WORD $0xb5fffe06 // cbnz x6, LBB0_74 $-64(%rip) +LBB0_79: + WORD $0x910083ed // add x13, sp, #32 + WORD $0x17ffff1f // b LBB0_58 $-900(%rip) +LBB0_80: + WORD $0x91001528 // add x8, x9, #5 + WORD $0xf940040a // ldr x10, [x0, #8] + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x54002449 // b.ls LBB0_109 $1160(%rip) +LBB0_81: + WORD $0x92800008 // mov x8, #-1 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0xa9484ff4 // ldp x20, x19, [sp, #128] + WORD $0xa94757f6 // ldp x22, x21, [sp, #112] + WORD $0xa9465ff8 // ldp x24, x23, [sp, #96] + WORD $0x910243ff // add sp, sp, #144 + WORD $0xd65f03c0 // ret +LBB0_82: + WORD $0xd2800004 // mov x4, #0 + WORD $0xd280000b // mov x11, #0 + WORD $0xd2800008 // mov x8, #0 + WORD $0xd280000a // mov x10, #0 + WORD $0xf940040e // ldr x14, [x0, #8] + WORD $0xcb0d01c2 // sub x2, x14, x13 + WORD $0x8b0d018d // add x13, x12, x13 + WORD $0x910083ec // add x12, sp, #32 + WORD $0x9100818c // add x12, x12, #32 + WORD $0x4f01e440 // movi.16b v0, #34 +Lloh14: + WORD $0x10ffbf4e // adr x14, lCPI0_0 $-2072(%rip) +Lloh15: + WORD $0x3dc001c1 // ldr q1, [x14, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x4f02e782 // movi.16b v2, #92 +Lloh16: + WORD $0x10ffbf6e // adr x14, lCPI0_1 $-2068(%rip) +Lloh17: + WORD $0x3dc001c3 // ldr q3, [x14, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0xb200e3ee // mov x14, #1229782938247303441 + WORD $0xb201e3ef // mov x15, #-8608480567731124088 + WORD $0xb202e3f0 // mov x16, #4919131752989213764 + WORD $0xb203e3f1 // mov x17, #2459565876494606882 + WORD $0x4f03e764 // movi.16b v4, #123 + WORD $0x4f03e7a5 // movi.16b v5, #125 + WORD $0x6f00e406 // movi.2d v6, #0000000000000000 + WORD $0x14000009 // b LBB0_84 $36(%rip) +LBB0_83: + WORD $0x937ffc84 // asr x4, x4, #63 + WORD $0x9e6700a7 // fmov d7, x5 + WORD $0x0e2058e7 // cnt.8b v7, v7 + WORD $0x2e3038e7 // uaddlv.8b h7, v7 + WORD $0x1e2600e2 // fmov w2, s7 + WORD $0x8b080048 // add x8, x2, x8 + WORD $0x910101ad // add x13, x13, #64 + WORD $0xaa0303e2 // mov x2, x3 +LBB0_84: + WORD $0xf1010043 // subs x3, x2, #64 + WORD $0x540015eb // b.lt LBB0_91 $700(%rip) +LBB0_85: + WORD $0xad4045b2 // ldp q18, q17, [x13] + WORD $0xad411db0 // ldp q16, q7, [x13, #32] + WORD $0x6e228e53 // cmeq.16b v19, v18, v2 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260265 // fmov w5, s19 + WORD $0x6e228e33 // cmeq.16b v19, v17, v2 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260266 // fmov w6, s19 + WORD $0x6e228e13 // cmeq.16b v19, v16, v2 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260267 // fmov w7, s19 + WORD $0x6e228cf3 // cmeq.16b v19, v7, v2 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260273 // fmov w19, s19 + WORD $0xd3607ce7 // lsl x7, x7, #32 + WORD $0xb3503e67 // bfi x7, x19, #48, #16 + WORD $0x53103cc6 // lsl w6, w6, #16 + WORD $0xaa0600e6 // orr x6, x7, x6 + WORD $0xaa0500c5 // orr x5, x6, x5 + WORD $0xaa0b00a6 // orr x6, x5, x11 + WORD $0xb5000086 // cbnz x6, LBB0_87 $16(%rip) + WORD $0xd280000b // mov x11, #0 + WORD $0x92800005 // mov x5, #-1 + WORD $0x1400000b // b LBB0_88 $44(%rip) +LBB0_87: + WORD $0x8a2b00a6 // bic x6, x5, x11 + WORD $0xaa060567 // orr x7, x11, x6, lsl #1 + WORD $0x8a2700ab // bic x11, x5, x7 + WORD $0x9201f16b // and x11, x11, #0xaaaaaaaaaaaaaaaa + WORD $0xab060165 // adds x5, x11, x6 + WORD $0x1a9f37eb // cset w11, hs + WORD $0xd37ff8a5 // lsl x5, x5, #1 + WORD $0xd200f0a5 // eor x5, x5, #0x5555555555555555 + WORD $0x8a0700a5 // and x5, x5, x7 + WORD $0xaa2503e5 // mvn x5, x5 +LBB0_88: + WORD $0x6e208e53 // cmeq.16b v19, v18, v0 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x6e208e34 // cmeq.16b v20, v17, v0 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x6e208e15 // cmeq.16b v21, v16, v0 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x6e208cf6 // cmeq.16b v22, v7, v0 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0302d6 // tbl.16b v22, { v22 }, v3 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c6 // fmov w6, s22 + WORD $0xd3503cc6 // lsl x6, x6, #48 + WORD $0x4e0302b5 // tbl.16b v21, { v21 }, v3 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602a7 // fmov w7, s21 + WORD $0xb3603ce6 // bfi x6, x7, #32, #16 + WORD $0x4e030294 // tbl.16b v20, { v20 }, v3 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260287 // fmov w7, s20 + WORD $0x53103ce7 // lsl w7, w7, #16 + WORD $0xaa0700c6 // orr x6, x6, x7 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260267 // fmov w7, s19 + WORD $0xaa0700c6 // orr x6, x6, x7 + WORD $0x8a0500c5 // and x5, x6, x5 + WORD $0x9200e0a6 // and x6, x5, #0x1111111111111111 + WORD $0x9203e0a7 // and x7, x5, #0x2222222222222222 + WORD $0x9202e0b3 // and x19, x5, #0x4444444444444444 + WORD $0x9201e0a5 // and x5, x5, #0x8888888888888888 + WORD $0x9b0e7cd4 // mul x20, x6, x14 + WORD $0x9b0f7cf5 // mul x21, x7, x15 + WORD $0xca150294 // eor x20, x20, x21 + WORD $0x9b107e75 // mul x21, x19, x16 + WORD $0xca150294 // eor x20, x20, x21 + WORD $0x9b117cb5 // mul x21, x5, x17 + WORD $0xca150294 // eor x20, x20, x21 + WORD $0x9b117cd5 // mul x21, x6, x17 + WORD $0x9b0e7cf6 // mul x22, x7, x14 + WORD $0xca1602b5 // eor x21, x21, x22 + WORD $0x9b0f7e76 // mul x22, x19, x15 + WORD $0xca1602b5 // eor x21, x21, x22 + WORD $0x9b107cb6 // mul x22, x5, x16 + WORD $0xca1602b5 // eor x21, x21, x22 + WORD $0x9b107cd6 // mul x22, x6, x16 + WORD $0x9b117cf7 // mul x23, x7, x17 + WORD $0xca1702d6 // eor x22, x22, x23 + WORD $0x9b0e7e77 // mul x23, x19, x14 + WORD $0xca1702d6 // eor x22, x22, x23 + WORD $0x9b0f7cb7 // mul x23, x5, x15 + WORD $0xca1702d6 // eor x22, x22, x23 + WORD $0x9b0f7cc6 // mul x6, x6, x15 + WORD $0x9b107ce7 // mul x7, x7, x16 + WORD $0xca0700c6 // eor x6, x6, x7 + WORD $0x9b117e67 // mul x7, x19, x17 + WORD $0xca0700c6 // eor x6, x6, x7 + WORD $0x9b0e7ca5 // mul x5, x5, x14 + WORD $0xca0500c5 // eor x5, x6, x5 + WORD $0x9200e286 // and x6, x20, #0x1111111111111111 + WORD $0x9203e2a7 // and x7, x21, #0x2222222222222222 + WORD $0x9202e2d3 // and x19, x22, #0x4444444444444444 + WORD $0x9201e0a5 // and x5, x5, #0x8888888888888888 + WORD $0xaa0700c6 // orr x6, x6, x7 + WORD $0xaa1300c6 // orr x6, x6, x19 + WORD $0xaa0500c5 // orr x5, x6, x5 + WORD $0xca0400a4 // eor x4, x5, x4 + WORD $0x6e248e53 // cmeq.16b v19, v18, v4 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260265 // fmov w5, s19 + WORD $0x6e248e33 // cmeq.16b v19, v17, v4 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260266 // fmov w6, s19 + WORD $0x6e248e13 // cmeq.16b v19, v16, v4 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260267 // fmov w7, s19 + WORD $0x6e248cf3 // cmeq.16b v19, v7, v4 + WORD $0x4e211e73 // and.16b v19, v19, v1 + WORD $0x4e030273 // tbl.16b v19, { v19 }, v3 + WORD $0x4e71ba73 // addv.8h h19, v19 + WORD $0x1e260273 // fmov w19, s19 + WORD $0xd3607ce7 // lsl x7, x7, #32 + WORD $0xb3503e67 // bfi x7, x19, #48, #16 + WORD $0x53103cc6 // lsl w6, w6, #16 + WORD $0xaa0600e6 // orr x6, x7, x6 + WORD $0xaa0500c5 // orr x5, x6, x5 + WORD $0x8a2400a5 // bic x5, x5, x4 + WORD $0x6e258e52 // cmeq.16b v18, v18, v5 + WORD $0x4e211e52 // and.16b v18, v18, v1 + WORD $0x4e030252 // tbl.16b v18, { v18 }, v3 + WORD $0x4e71ba52 // addv.8h h18, v18 + WORD $0x1e260246 // fmov w6, s18 + WORD $0x6e258e31 // cmeq.16b v17, v17, v5 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e030231 // tbl.16b v17, { v17 }, v3 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260227 // fmov w7, s17 + WORD $0x6e258e10 // cmeq.16b v16, v16, v5 + WORD $0x4e211e10 // and.16b v16, v16, v1 + WORD $0x4e030210 // tbl.16b v16, { v16 }, v3 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e260213 // fmov w19, s16 + WORD $0x6e258ce7 // cmeq.16b v7, v7, v5 + WORD $0x4e211ce7 // and.16b v7, v7, v1 + WORD $0x4e0300e7 // tbl.16b v7, { v7 }, v3 + WORD $0x4e71b8e7 // addv.8h h7, v7 + WORD $0x1e2600f4 // fmov w20, s7 + WORD $0xd3607e73 // lsl x19, x19, #32 + WORD $0xb3503e93 // bfi x19, x20, #48, #16 + WORD $0x53103ce7 // lsl w7, w7, #16 + WORD $0xaa070267 // orr x7, x19, x7 + WORD $0xaa0600e6 // orr x6, x7, x6 + WORD $0xea2400c6 // bics x6, x6, x4 + WORD $0x54ffeac0 // b.eq LBB0_83 $-680(%rip) +LBB0_89: + WORD $0xd10004c7 // sub x7, x6, #1 + WORD $0x8a0500f3 // and x19, x7, x5 + WORD $0x9e670267 // fmov d7, x19 + WORD $0x0e2058e7 // cnt.8b v7, v7 + WORD $0x2e3038e7 // uaddlv.8b h7, v7 + WORD $0x1e2600f3 // fmov w19, s7 + WORD $0x8b080273 // add x19, x19, x8 + WORD $0xeb0a027f // cmp x19, x10 + WORD $0x54000729 // b.ls LBB0_107 $228(%rip) + WORD $0x9100054a // add x10, x10, #1 + WORD $0xea0600e6 // ands x6, x7, x6 + WORD $0x54fffea1 // b.ne LBB0_89 $-44(%rip) + WORD $0x17ffff49 // b LBB0_83 $-732(%rip) +LBB0_91: + WORD $0xf100005f // cmp x2, #0 + WORD $0x54000cad // b.le LBB0_116 $404(%rip) + WORD $0xad021be6 // stp q6, q6, [sp, #64] + WORD $0xad011be6 // stp q6, q6, [sp, #32] + WORD $0x92402da5 // and x5, x13, #0xfff + WORD $0xf13f04bf // cmp x5, #4033 + WORD $0x54ffe983 // b.lo LBB0_85 $-720(%rip) + WORD $0xf1008046 // subs x6, x2, #32 + WORD $0x54000103 // b.lo LBB0_95 $32(%rip) + WORD $0x3dc001a7 // ldr q7, [x13] + WORD $0x3d800be7 // str q7, [sp, #32] + WORD $0x3dc005a7 // ldr q7, [x13, #16] + WORD $0x3d800fe7 // str q7, [sp, #48] + WORD $0x910081ad // add x13, x13, #32 + WORD $0xaa0c03e5 // mov x5, x12 + WORD $0x14000003 // b LBB0_96 $12(%rip) +LBB0_95: + WORD $0x910083e5 // add x5, sp, #32 + WORD $0xaa0203e6 // mov x6, x2 +LBB0_96: + WORD $0xf10040c7 // subs x7, x6, #16 + WORD $0x54000243 // b.lo LBB0_102 $72(%rip) + WORD $0x3cc105a7 // ldr q7, [x13], #16 + WORD $0x3c8104a7 // str q7, [x5], #16 + WORD $0xaa0703e6 // mov x6, x7 + WORD $0xf10020c7 // subs x7, x6, #8 + WORD $0x540001e2 // b.hs LBB0_103 $60(%rip) +LBB0_98: + WORD $0xf10010c7 // subs x7, x6, #4 + WORD $0x54000243 // b.lo LBB0_104 $72(%rip) +LBB0_99: + WORD $0xb84045a6 // ldr w6, [x13], #4 + WORD $0xb80044a6 // str w6, [x5], #4 + WORD $0xaa0703e6 // mov x6, x7 + WORD $0xf10008c7 // subs x7, x6, #2 + WORD $0x540001e2 // b.hs LBB0_105 $60(%rip) +LBB0_100: + WORD $0xb4000246 // cbz x6, LBB0_106 $72(%rip) +LBB0_101: + WORD $0x394001ad // ldrb w13, [x13] + WORD $0x390000ad // strb w13, [x5] + WORD $0x910083ed // add x13, sp, #32 + WORD $0x17ffff2e // b LBB0_85 $-840(%rip) +LBB0_102: + WORD $0xf10020c7 // subs x7, x6, #8 + WORD $0x54fffe63 // b.lo LBB0_98 $-52(%rip) +LBB0_103: + WORD $0xf84085a6 // ldr x6, [x13], #8 + WORD $0xf80084a6 // str x6, [x5], #8 + WORD $0xaa0703e6 // mov x6, x7 + WORD $0xf10010c7 // subs x7, x6, #4 + WORD $0x54fffe02 // b.hs LBB0_99 $-64(%rip) +LBB0_104: + WORD $0xf10008c7 // subs x7, x6, #2 + WORD $0x54fffe63 // b.lo LBB0_100 $-52(%rip) +LBB0_105: + WORD $0x784025a6 // ldrh w6, [x13], #2 + WORD $0x780024a6 // strh w6, [x5], #2 + WORD $0xaa0703e6 // mov x6, x7 + WORD $0xb5fffe06 // cbnz x6, LBB0_101 $-64(%rip) +LBB0_106: + WORD $0x910083ed // add x13, sp, #32 + WORD $0x17ffff1f // b LBB0_85 $-900(%rip) +LBB0_107: + WORD $0xf9400408 // ldr x8, [x0, #8] + WORD $0xdac000ca // rbit x10, x6 + WORD $0xdac0114a // clz x10, x10 + WORD $0xcb02014a // sub x10, x10, x2 + WORD $0x8b080148 // add x8, x10, x8 + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900002a // str x10, [x1] + WORD $0xf940040b // ldr x11, [x0, #8] + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x9a888568 // csinc x8, x11, x8, hi + WORD $0xf9000028 // str x8, [x1] + WORD $0xda9f9128 // csinv x8, x9, xzr, ls + WORD $0xaa0803e0 // mov x0, x8 + WORD $0xa9484ff4 // ldp x20, x19, [sp, #128] + WORD $0xa94757f6 // ldp x22, x21, [sp, #112] + WORD $0xa9465ff8 // ldp x24, x23, [sp, #96] + WORD $0x910243ff // add sp, sp, #144 + WORD $0xd65f03c0 // ret +LBB0_108: + WORD $0x5ac001ea // rbit w10, w15 + WORD $0x5ac0114a // clz w10, w10 + WORD $0x8b0a012a // add x10, x9, x10 + WORD $0x8b080148 // add x8, x10, x8 + WORD $0x91000908 // add x8, x8, #2 +LBB0_109: + WORD $0xf9000028 // str x8, [x1] + WORD $0x17fffd7c // b LBB0_42 $-2576(%rip) +LBB0_110: + WORD $0x92800028 // mov x8, #-2 + WORD $0x5280004d // mov w13, #2 + WORD $0x8b0d016b // add x11, x11, x13 + WORD $0x8b0a010a // add x10, x8, x10 + WORD $0x92800008 // mov x8, #-1 + WORD $0xf100015f // cmp x10, #0 + WORD $0x54ffa60d // b.le LBB0_22 $-2880(%rip) +LBB0_111: + WORD $0x39400168 // ldrb w8, [x11] + WORD $0x7101711f // cmp w8, #92 + WORD $0x54fffee0 // b.eq LBB0_110 $-36(%rip) + WORD $0x7100891f // cmp w8, #34 + WORD $0x54000120 // b.eq LBB0_114 $36(%rip) + WORD $0x92800008 // mov x8, #-1 + WORD $0x5280002d // mov w13, #1 + WORD $0x8b0d016b // add x11, x11, x13 + WORD $0x8b0a010a // add x10, x8, x10 + WORD $0x92800008 // mov x8, #-1 + WORD $0xf100015f // cmp x10, #0 + WORD $0x54fffeac // b.gt LBB0_111 $-44(%rip) + WORD $0x17fffd23 // b LBB0_22 $-2932(%rip) +LBB0_114: + WORD $0xcb0c0168 // sub x8, x11, x12 + WORD $0x91000508 // add x8, x8, #1 + WORD $0x17ffffe8 // b LBB0_109 $-96(%rip) +LBB0_115: + WORD $0x8b0d018b // add x11, x12, x13 + WORD $0x17fffdbb // b LBB0_54 $-2324(%rip) +LBB0_116: + WORD $0xf9400408 // ldr x8, [x0, #8] + WORD $0xf9000028 // str x8, [x1] + WORD $0x17fffec2 // b LBB0_81 $-1272(%rip) +LBB0_117: + WORD $0xd100054b // sub x11, x10, #1 + WORD $0xeb08017f // cmp x11, x8 + WORD $0x54ffd7e0 // b.eq LBB0_81 $-1284(%rip) + WORD $0x8b09018b // add x11, x12, x9 + WORD $0x8b08016b // add x11, x11, x8 + WORD $0x9100096b // add x11, x11, #2 + WORD $0xcb080148 // sub x8, x10, x8 + WORD $0xd100090a // sub x10, x8, #2 + WORD $0x17fffdaf // b LBB0_54 $-2372(%rip) + // .p2align 1, 0x00 +LJTI0_0: + WORD $0x00510000 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510059 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00160051 + WORD $0x00510051 + WORD $0x00160016 + WORD $0x00160016 + WORD $0x00160016 + WORD $0x00160016 + WORD $0x00160016 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00a00051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x005101a3 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x00510051 + WORD $0x0051004c + WORD $0x00510051 + WORD $0x00510051 + WORD $0x0051004c + WORD $0x00510051 + WORD $0x00510051 + WORD $0x01ae0051 + // // .word (LBB0_22-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_45-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_28-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_55-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_80-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_43-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_43-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_44-LBB0_22)>>2 +// .word (LBB0_82-LBB0_22)>>2 + +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__skip_one_fast(SB), $0-24 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $176, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_skip_one_fast: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + CALL ·__skip_one_fast_arm64_entry__+60(SB) // _skip_one_fast + MOVD R0, ret+16(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/skip_one_fast_subr_arm64.go b/internal/native/neon/skip_one_fast_subr_arm64.go new file mode 100644 index 000000000..39bd7b053 --- /dev/null +++ b/internal/native/neon/skip_one_fast_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __skip_one_fast_arm64_entry__() uintptr + +var ( + _subr__skip_one_fast uintptr = __skip_one_fast_arm64_entry__() + 48 +) + +const ( + _stack__skip_one_fast = 144 +) + +var ( + _ = _subr__skip_one_fast +) + +const ( + _ = _stack__skip_one_fast +) diff --git a/internal/native/neon/skip_one_subr_arm64.go b/internal/native/neon/skip_one_subr_arm64.go new file mode 100644 index 000000000..57d9ae5dc --- /dev/null +++ b/internal/native/neon/skip_one_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __skip_one_arm64_entry__() uintptr + +var ( + _subr__skip_one uintptr = __skip_one_arm64_entry__() + 64 +) + +const ( + _stack__skip_one = 160 +) + +var ( + _ = _subr__skip_one +) + +const ( + _ = _stack__skip_one +) diff --git a/internal/native/neon/u64toa_arm64.go b/internal/native/neon/u64toa_arm64.go new file mode 100644 index 000000000..a3dcad891 --- /dev/null +++ b/internal/native/neon/u64toa_arm64.go @@ -0,0 +1,31 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +//go:nosplit +func u64toa(out *byte, val uint64) (ret int) { + return __u64toa(out, val) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __u64toa(out *byte, val uint64) (ret int) diff --git a/internal/native/neon/u64toa_arm64.s b/internal/native/neon/u64toa_arm64.s new file mode 100644 index 000000000..4fe7cdcbd --- /dev/null +++ b/internal/native/neon/u64toa_arm64.s @@ -0,0 +1,586 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__u64toa_arm64_entry__(SB), NOSPLIT, $16 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 3, 0x00 +lCPI0_0: + WORD $0x147b20c5 + WORD $0x80003334 + // // .word 8389 +// .word 5243 +// .word 13108 +// .word 32768 + +lCPI0_1: + WORD $0x08000080 + WORD $0x80002000 + // // .word 128 +// .word 2048 +// .word 8192 +// .word 32768 + +lCPI0_2: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_3: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_u64toa: + MOVD.W R30, -32(RSP) // WORD $0xf81e0ffe // str x30, [sp, #-32]! + WORD $0xd344fc28 // lsr x8, x1, #4 + WORD $0xf109c11f // cmp x8, #624 + WORD $0x54000608 // b.hi LBB0_9 $192(%rip) + WORD $0x53023c28 // ubfx w8, w1, #2, #14 + WORD $0x52828f69 // mov w9, #5243 + WORD $0x1b097d08 // mul w8, w8, w9 + WORD $0x53117d08 // lsr w8, w8, #17 + WORD $0xd37ff909 // lsl x9, x8, #1 + WORD $0x52800c8a // mov w10, #100 + WORD $0x1b0a8508 // msub w8, w8, w10, w1 + WORD $0x92403d08 // and x8, x8, #0xffff + WORD $0xd37ff908 // lsl x8, x8, #1 + WORD $0x710fa03f // cmp w1, #1000 + WORD $0x540000e3 // b.lo LBB0_3 $28(%rip) +Lloh0: + WORD $0x100029ca // adr x10, _Digits $1336(%rip) +Lloh1: + WORD $0x9100014a // add x10, x10, _Digits@PAGEOFF $0(%rip) + WORD $0x3869694a // ldrb w10, [x10, x9] + WORD $0x3900000a // strb w10, [x0] + WORD $0x5280002a // mov w10, #1 + WORD $0x14000004 // b LBB0_5 $16(%rip) +LBB0_3: + WORD $0x7101903f // cmp w1, #100 + WORD $0x54000303 // b.lo LBB0_8 $96(%rip) + WORD $0x5280000a // mov w10, #0 +LBB0_5: + WORD $0x2a0903e9 // mov w9, w9 +Lloh2: + WORD $0x1000288b // adr x11, _Digits $1296(%rip) +Lloh3: + WORD $0x9100016b // add x11, x11, _Digits@PAGEOFF $0(%rip) + WORD $0xb2400129 // orr x9, x9, #0x1 + WORD $0x38696969 // ldrb w9, [x11, x9] + WORD $0x1100054b // add w11, w10, #1 + WORD $0x382a4809 // strb w9, [x0, w10, uxtw] +LBB0_6: +Lloh4: + WORD $0x100027c9 // adr x9, _Digits $1272(%rip) +Lloh5: + WORD $0x91000129 // add x9, x9, _Digits@PAGEOFF $0(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x11000569 // add w9, w11, #1 + WORD $0x382b480a // strb w10, [x0, w11, uxtw] +LBB0_7: + WORD $0x32000108 // orr w8, w8, #0x1 +Lloh6: + WORD $0x1000270a // adr x10, _Digits $1248(%rip) +Lloh7: + WORD $0x9100014a // add x10, x10, _Digits@PAGEOFF $0(%rip) + WORD $0x92403d08 // and x8, x8, #0xffff + WORD $0x3868694a // ldrb w10, [x10, x8] + WORD $0x11000528 // add w8, w9, #1 + WORD $0x3829480a // strb w10, [x0, w9, uxtw] + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_8: + WORD $0x5280000b // mov w11, #0 + WORD $0x52800009 // mov w9, #0 + WORD $0x7100283f // cmp w1, #10 + WORD $0x54fffdc2 // b.hs LBB0_6 $-72(%rip) + WORD $0x17fffff2 // b LBB0_7 $-56(%rip) +LBB0_9: + WORD $0x529c2008 // mov w8, #57600 + WORD $0x72a0bea8 // movk w8, #1525, lsl #16 + WORD $0xeb08003f // cmp x1, x8 + WORD $0x54000a42 // b.hs LBB0_18 $328(%rip) + WORD $0x528847ec // mov w12, #16959 + WORD $0x72a001ec // movk w12, #15, lsl #16 + WORD $0x92407c28 // and x8, x1, #0xffffffff + WORD $0x5282eb29 // mov w9, #5977 + WORD $0x72ba36e9 // movk w9, #53687, lsl #16 + WORD $0x9b097d08 // mul x8, x8, x9 + WORD $0xd36dfd08 // lsr x8, x8, #45 + WORD $0x5284e209 // mov w9, #10000 + WORD $0x1b09850d // msub w13, w8, w9, w1 + WORD $0x11000589 // add w9, w12, #1 + WORD $0x1ac90829 // udiv w9, w1, w9 + WORD $0xd37ff92b // lsl x11, x9, #1 + WORD $0x53023d09 // ubfx w9, w8, #2, #14 + WORD $0x52828f6e // mov w14, #5243 + WORD $0x1b0e7d29 // mul w9, w9, w14 + WORD $0x53117d29 // lsr w9, w9, #17 + WORD $0x52800c8f // mov w15, #100 + WORD $0x1b0fa128 // msub w8, w9, w15, w8 + WORD $0x92403d08 // and x8, x8, #0xffff + WORD $0xd37ff90a // lsl x10, x8, #1 + WORD $0x53023da8 // ubfx w8, w13, #2, #14 + WORD $0x1b0e7d08 // mul w8, w8, w14 + WORD $0x53117d08 // lsr w8, w8, #17 + WORD $0xd37ff909 // lsl x9, x8, #1 + WORD $0x1b0fb508 // msub w8, w8, w15, w13 + WORD $0x92403d08 // and x8, x8, #0xffff + WORD $0xd37ff908 // lsl x8, x8, #1 + WORD $0x5292d00d // mov w13, #38528 + WORD $0x72a0130d // movk w13, #152, lsl #16 + WORD $0x6b0d003f // cmp w1, w13 + WORD $0x540000e3 // b.lo LBB0_12 $28(%rip) +Lloh8: + WORD $0x100020ec // adr x12, _Digits $1052(%rip) +Lloh9: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0x386b698c // ldrb w12, [x12, x11] + WORD $0x3900000c // strb w12, [x0] + WORD $0x5280002d // mov w13, #1 + WORD $0x14000004 // b LBB0_14 $16(%rip) +LBB0_12: + WORD $0x6b0c003f // cmp w1, w12 + WORD $0x540004a9 // b.ls LBB0_17 $148(%rip) + WORD $0x5280000d // mov w13, #0 +LBB0_14: + WORD $0x2a0b03eb // mov w11, w11 +Lloh10: + WORD $0x10001fac // adr x12, _Digits $1012(%rip) +Lloh11: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0xb240016b // orr x11, x11, #0x1 + WORD $0x386b698b // ldrb w11, [x12, x11] + WORD $0x110005ac // add w12, w13, #1 + WORD $0x382d480b // strb w11, [x0, w13, uxtw] +LBB0_15: +Lloh12: + WORD $0x10001eeb // adr x11, _Digits $988(%rip) +Lloh13: + WORD $0x9100016b // add x11, x11, _Digits@PAGEOFF $0(%rip) + WORD $0x386a696d // ldrb w13, [x11, x10] + WORD $0x1100058b // add w11, w12, #1 + WORD $0x382c480d // strb w13, [x0, w12, uxtw] +LBB0_16: + WORD $0x3200014a // orr w10, w10, #0x1 + WORD $0x92403d4a // and x10, x10, #0xffff +Lloh14: + WORD $0x10001e0c // adr x12, _Digits $960(%rip) +Lloh15: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0x386a698a // ldrb w10, [x12, x10] + WORD $0x8b2b400d // add x13, x0, w11, uxtw + WORD $0x390001aa // strb w10, [x13] + WORD $0x3869698a // ldrb w10, [x12, x9] + WORD $0x390005aa // strb w10, [x13, #1] + WORD $0x2a0903e9 // mov w9, w9 + WORD $0xb2400129 // orr x9, x9, #0x1 + WORD $0x38696989 // ldrb w9, [x12, x9] + WORD $0x390009a9 // strb w9, [x13, #2] + WORD $0x38686989 // ldrb w9, [x12, x8] + WORD $0x39000da9 // strb w9, [x13, #3] + WORD $0x32000108 // orr w8, w8, #0x1 + WORD $0x92403d08 // and x8, x8, #0xffff + WORD $0x38686989 // ldrb w9, [x12, x8] + WORD $0x11001568 // add w8, w11, #5 + WORD $0x390011a9 // strb w9, [x13, #4] + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_17: + WORD $0x5280000c // mov w12, #0 + WORD $0x5280000b // mov w11, #0 + WORD $0x53057c2d // lsr w13, w1, #5 + WORD $0x7130d5bf // cmp w13, #3125 + WORD $0x54fffc02 // b.hs LBB0_15 $-128(%rip) + WORD $0x17ffffe4 // b LBB0_16 $-112(%rip) +LBB0_18: + WORD $0xd2adf829 // mov x9, #1874919424 + WORD $0xf2d0de49 // movk x9, #34546, lsl #32 + WORD $0xf2e00469 // movk x9, #35, lsl #48 + WORD $0xeb09003f // cmp x1, x9 + WORD $0x54000b02 // b.hs LBB0_20 $352(%rip) + WORD $0x9ac80829 // udiv x9, x1, x8 + WORD $0x1b088528 // msub w8, w9, w8, w1 + WORD $0x6f00e400 // movi.2d v0, #0000000000000000 + WORD $0x6f00e401 // movi.2d v1, #0000000000000000 + WORD $0x4e041d21 // mov.s v1[0], w9 + WORD $0x0ea12822 // xtn.2s v2, v1 + WORD $0x5282eb29 // mov w9, #5977 + WORD $0x72ba36e9 // movk w9, #53687, lsl #16 + WORD $0x0e040d23 // dup.2s v3, w9 + WORD $0x2ea3c042 // umull.2d v2, v2, v3 + WORD $0x6f530442 // ushr.2d v2, v2, #45 + WORD $0x0ea12844 // xtn.2s v4, v2 + WORD $0x5284e209 // mov w9, #10000 + WORD $0x0e040d25 // dup.2s v5, w9 + WORD $0x2ea5c084 // umull.2d v4, v4, v5 + WORD $0x6ea48421 // sub.4s v1, v1, v4 + WORD $0x4e413841 // zip1.8h v1, v2, v1 + WORD $0x4f425421 // shl.2d v1, v1, #2 + WORD $0x4e413821 // zip1.8h v1, v1, v1 + WORD $0x4e813821 // zip1.4s v1, v1, v1 +Lloh16: + WORD $0x10ffea69 // adr x9, lCPI0_0 $-692(%rip) +Lloh17: + WORD $0xfd400122 // ldr d2, [x9, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x2e62c024 // umull.4s v4, v1, v2 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e62c021 // umull.4s v1, v1, v2 + WORD $0x4e415881 // uzp2.8h v1, v4, v1 +Lloh18: + WORD $0x10ffe9e9 // adr x9, lCPI0_1 $-708(%rip) +Lloh19: + WORD $0xfd400124 // ldr d4, [x9, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x2e64c026 // umull.4s v6, v1, v4 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e64c021 // umull.4s v1, v1, v4 + WORD $0x4e4158c1 // uzp2.8h v1, v6, v1 + WORD $0x4f008546 // movi.8h v6, #10 + WORD $0x4e669c27 // mul.8h v7, v1, v6 + WORD $0x4f5054e7 // shl.2d v7, v7, #16 + WORD $0x6e678421 // sub.8h v1, v1, v7 + WORD $0x4e041d00 // mov.s v0[0], w8 + WORD $0x0ea12807 // xtn.2s v7, v0 + WORD $0x2ea3c0e3 // umull.2d v3, v7, v3 + WORD $0x6f530463 // ushr.2d v3, v3, #45 + WORD $0x0ea12867 // xtn.2s v7, v3 + WORD $0x2ea5c0e5 // umull.2d v5, v7, v5 + WORD $0x6ea58400 // sub.4s v0, v0, v5 + WORD $0x4e403860 // zip1.8h v0, v3, v0 + WORD $0x4f425400 // shl.2d v0, v0, #2 + WORD $0x4e403800 // zip1.8h v0, v0, v0 + WORD $0x4e803800 // zip1.4s v0, v0, v0 + WORD $0x2e62c003 // umull.4s v3, v0, v2 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e62c000 // umull.4s v0, v0, v2 + WORD $0x4e405860 // uzp2.8h v0, v3, v0 + WORD $0x2e64c002 // umull.4s v2, v0, v4 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e64c000 // umull.4s v0, v0, v4 + WORD $0x4e405840 // uzp2.8h v0, v2, v0 + WORD $0x4e669c02 // mul.8h v2, v0, v6 + WORD $0x4f505442 // shl.2d v2, v2, #16 + WORD $0x6e628400 // sub.8h v0, v0, v2 + WORD $0x2e212821 // sqxtun.8b v1, v1 + WORD $0x6e212801 // sqxtun2.16b v1, v0 + WORD $0x4f01e600 // movi.16b v0, #48 + WORD $0x4e208420 // add.16b v0, v1, v0 + WORD $0x4e209821 // cmeq.16b v1, v1, #0 +Lloh20: + WORD $0x10ffe588 // adr x8, lCPI0_2 $-848(%rip) +Lloh21: + WORD $0x3dc00102 // ldr q2, [x8, lCPI0_2@PAGEOFF] $0(%rip) + WORD $0x4e221c21 // and.16b v1, v1, v2 +Lloh22: + WORD $0x10ffe5a8 // adr x8, lCPI0_3 $-844(%rip) +Lloh23: + WORD $0x3dc00102 // ldr q2, [x8, lCPI0_3@PAGEOFF] $0(%rip) + WORD $0x4e020021 // tbl.16b v1, { v1 }, v2 + WORD $0x4e71b821 // addv.8h h1, v1 + WORD $0x1e260028 // fmov w8, s1 + WORD $0x2a2803e8 // mvn w8, w8 + WORD $0x32114108 // orr w8, w8, #0xffff8000 + WORD $0x5ac00108 // rbit w8, w8 + WORD $0x5ac01108 // clz w8, w8 +Lloh24: + WORD $0x10001709 // adr x9, _VecShiftShuffles $736(%rip) +Lloh25: + WORD $0x91000129 // add x9, x9, _VecShiftShuffles@PAGEOFF $0(%rip) + WORD $0x3ce85921 // ldr q1, [x9, w8, uxtw #4] + WORD $0x4f04e5e2 // movi.16b v2, #143 + WORD $0x4e221c21 // and.16b v1, v1, v2 + WORD $0x4e010000 // tbl.16b v0, { v0 }, v1 + WORD $0x3d800000 // str q0, [x0] + WORD $0x52800209 // mov w9, #16 + WORD $0x4b080128 // sub w8, w9, w8 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_20: + WORD $0x9ac9082a // udiv x10, x1, x9 + WORD $0x9b098549 // msub x9, x10, x9, x1 + WORD $0x7100255f // cmp w10, #9 + WORD $0x540000a8 // b.hi LBB0_22 $20(%rip) + WORD $0x1100c14a // add w10, w10, #48 + WORD $0x3900000a // strb w10, [x0] + WORD $0x5280002a // mov w10, #1 + WORD $0x1400002f // b LBB0_27 $188(%rip) +LBB0_22: + WORD $0x71018d5f // cmp w10, #99 + WORD $0x540001a8 // b.hi LBB0_24 $52(%rip) + WORD $0x2a0a03ea // mov w10, w10 + WORD $0xd37ff94a // lsl x10, x10, #1 +Lloh26: + WORD $0x10000dab // adr x11, _Digits $436(%rip) +Lloh27: + WORD $0x9100016b // add x11, x11, _Digits@PAGEOFF $0(%rip) + WORD $0x386a696c // ldrb w12, [x11, x10] + WORD $0x3900000c // strb w12, [x0] + WORD $0x927f794a // and x10, x10, #0xfffffffe + WORD $0x8b0a016a // add x10, x11, x10 + WORD $0x3940054a // ldrb w10, [x10, #1] + WORD $0x3900040a // strb w10, [x0, #1] + WORD $0x5280004a // mov w10, #2 + WORD $0x14000021 // b LBB0_27 $132(%rip) +LBB0_24: + WORD $0x53023d4b // ubfx w11, w10, #2, #14 + WORD $0x52828f6c // mov w12, #5243 + WORD $0x1b0c7d6b // mul w11, w11, w12 + WORD $0x53117d6b // lsr w11, w11, #17 + WORD $0x710f9d5f // cmp w10, #999 + WORD $0x54000188 // b.hi LBB0_26 $48(%rip) + WORD $0x1100c16c // add w12, w11, #48 + WORD $0x3900000c // strb w12, [x0] + WORD $0x52800c8c // mov w12, #100 + WORD $0x1b0ca96a // msub w10, w11, w12, w10 + WORD $0x92403d4a // and x10, x10, #0xffff +Lloh28: + WORD $0x10000b0b // adr x11, _Digits $352(%rip) +Lloh29: + WORD $0x9100016b // add x11, x11, _Digits@PAGEOFF $0(%rip) + WORD $0x786a796a // ldrh w10, [x11, x10, lsl #1] + WORD $0x7800100a // sturh w10, [x0, #1] + WORD $0x5280006a // mov w10, #3 + WORD $0x14000010 // b LBB0_27 $64(%rip) +LBB0_26: +Lloh30: + WORD $0x10000a4c // adr x12, _Digits $328(%rip) +Lloh31: + WORD $0x9100018c // add x12, x12, _Digits@PAGEOFF $0(%rip) + WORD $0x786b598d // ldrh w13, [x12, w11, uxtw #1] + WORD $0x7900000d // strh w13, [x0] + WORD $0x52800c8d // mov w13, #100 + WORD $0x1b0da96a // msub w10, w11, w13, w10 + WORD $0x92403d4a // and x10, x10, #0xffff + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0x386a698b // ldrb w11, [x12, x10] + WORD $0x3900080b // strb w11, [x0, #2] + WORD $0x927f394a // and x10, x10, #0xfffe + WORD $0x8b0a018a // add x10, x12, x10 + WORD $0x3940054a // ldrb w10, [x10, #1] + WORD $0x39000c0a // strb w10, [x0, #3] + WORD $0x5280008a // mov w10, #4 +LBB0_27: + WORD $0x9ac8092b // udiv x11, x9, x8 + WORD $0x6f00e400 // movi.2d v0, #0000000000000000 + WORD $0x6f00e401 // movi.2d v1, #0000000000000000 + WORD $0x4e041d61 // mov.s v1[0], w11 + WORD $0x5282eb2c // mov w12, #5977 + WORD $0x72ba36ec // movk w12, #53687, lsl #16 + WORD $0x0e040d82 // dup.2s v2, w12 + WORD $0x0ea12823 // xtn.2s v3, v1 + WORD $0x2ea2c063 // umull.2d v3, v3, v2 + WORD $0x6f530463 // ushr.2d v3, v3, #45 + WORD $0x5284e20c // mov w12, #10000 + WORD $0x0e040d84 // dup.2s v4, w12 + WORD $0x0ea12865 // xtn.2s v5, v3 + WORD $0x2ea4c0a5 // umull.2d v5, v5, v4 + WORD $0x6ea58421 // sub.4s v1, v1, v5 + WORD $0x4e413861 // zip1.8h v1, v3, v1 + WORD $0x4f425421 // shl.2d v1, v1, #2 + WORD $0x4e413821 // zip1.8h v1, v1, v1 + WORD $0x4e813821 // zip1.4s v1, v1, v1 +Lloh32: + WORD $0x10ffd8ec // adr x12, lCPI0_0 $-1252(%rip) +Lloh33: + WORD $0xfd400183 // ldr d3, [x12, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x2e63c025 // umull.4s v5, v1, v3 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e63c021 // umull.4s v1, v1, v3 + WORD $0x4e4158a1 // uzp2.8h v1, v5, v1 +Lloh34: + WORD $0x10ffd86c // adr x12, lCPI0_1 $-1268(%rip) +Lloh35: + WORD $0xfd400185 // ldr d5, [x12, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x2e65c026 // umull.4s v6, v1, v5 + WORD $0x6e014021 // ext.16b v1, v1, v1, #8 + WORD $0x2e65c021 // umull.4s v1, v1, v5 + WORD $0x4e4158c1 // uzp2.8h v1, v6, v1 + WORD $0x4f008546 // movi.8h v6, #10 + WORD $0x4e669c27 // mul.8h v7, v1, v6 + WORD $0x4f5054e7 // shl.2d v7, v7, #16 + WORD $0x6e678421 // sub.8h v1, v1, v7 + WORD $0x1b08a568 // msub w8, w11, w8, w9 + WORD $0x4e041d00 // mov.s v0[0], w8 + WORD $0x0ea12807 // xtn.2s v7, v0 + WORD $0x2ea2c0e2 // umull.2d v2, v7, v2 + WORD $0x6f530442 // ushr.2d v2, v2, #45 + WORD $0x0ea12847 // xtn.2s v7, v2 + WORD $0x2ea4c0e4 // umull.2d v4, v7, v4 + WORD $0x6ea48400 // sub.4s v0, v0, v4 + WORD $0x4e403840 // zip1.8h v0, v2, v0 + WORD $0x4f425400 // shl.2d v0, v0, #2 + WORD $0x4e403800 // zip1.8h v0, v0, v0 + WORD $0x4e803800 // zip1.4s v0, v0, v0 + WORD $0x2e63c002 // umull.4s v2, v0, v3 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e63c000 // umull.4s v0, v0, v3 + WORD $0x4e405840 // uzp2.8h v0, v2, v0 + WORD $0x2e65c002 // umull.4s v2, v0, v5 + WORD $0x6e004000 // ext.16b v0, v0, v0, #8 + WORD $0x2e65c000 // umull.4s v0, v0, v5 + WORD $0x4e405840 // uzp2.8h v0, v2, v0 + WORD $0x4e669c02 // mul.8h v2, v0, v6 + WORD $0x4f505442 // shl.2d v2, v2, #16 + WORD $0x6e628400 // sub.8h v0, v0, v2 + WORD $0x2e212821 // sqxtun.8b v1, v1 + WORD $0x6e212801 // sqxtun2.16b v1, v0 + WORD $0x4f01e600 // movi.16b v0, #48 + WORD $0x4e208420 // add.16b v0, v1, v0 + WORD $0x3caa4800 // str q0, [x0, w10, uxtw] + WORD $0x321c0148 // orr w8, w10, #0x10 + WORD $0xaa0803e0 // mov x0, x8 + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +_Digits: + WORD $0x31303030 // .ascii 4, '0001020304050607' + WORD $0x33303230 // .ascii 4, '0203040506070809' + WORD $0x35303430 // .ascii 4, '0405060708091011' + WORD $0x37303630 // .ascii 4, '0607080910111213' + WORD $0x39303830 // .ascii 4, '0809101112131415' + WORD $0x31313031 // .ascii 4, '1011121314151617' + WORD $0x33313231 // .ascii 4, '1213141516171819' + WORD $0x35313431 // .ascii 4, '1415161718192021' + WORD $0x37313631 // .ascii 4, '1617181920212223' + WORD $0x39313831 // .ascii 4, '1819202122232425' + WORD $0x31323032 // .ascii 4, '2021222324252627' + WORD $0x33323232 // .ascii 4, '2223242526272829' + WORD $0x35323432 // .ascii 4, '2425262728293031' + WORD $0x37323632 // .ascii 4, '2627282930313233' + WORD $0x39323832 // .ascii 4, '2829303132333435' + WORD $0x31333033 // .ascii 4, '3031323334353637' + WORD $0x33333233 // .ascii 4, '3233343536373839' + WORD $0x35333433 // .ascii 4, '3435363738394041' + WORD $0x37333633 // .ascii 4, '3637383940414243' + WORD $0x39333833 // .ascii 4, '3839404142434445' + WORD $0x31343034 // .ascii 4, '4041424344454647' + WORD $0x33343234 // .ascii 4, '4243444546474849' + WORD $0x35343434 // .ascii 4, '4445464748495051' + WORD $0x37343634 // .ascii 4, '4647484950515253' + WORD $0x39343834 // .ascii 4, '4849505152535455' + WORD $0x31353035 // .ascii 4, '5051525354555657' + WORD $0x33353235 // .ascii 4, '5253545556575859' + WORD $0x35353435 // .ascii 4, '5455565758596061' + WORD $0x37353635 // .ascii 4, '5657585960616263' + WORD $0x39353835 // .ascii 4, '5859606162636465' + WORD $0x31363036 // .ascii 4, '6061626364656667' + WORD $0x33363236 // .ascii 4, '6263646566676869' + WORD $0x35363436 // .ascii 4, '6465666768697071' + WORD $0x37363636 // .ascii 4, '6667686970717273' + WORD $0x39363836 // .ascii 4, '6869707172737475' + WORD $0x31373037 // .ascii 4, '7071727374757677' + WORD $0x33373237 // .ascii 4, '7273747576777879' + WORD $0x35373437 // .ascii 4, '7475767778798081' + WORD $0x37373637 // .ascii 4, '7677787980818283' + WORD $0x39373837 // .ascii 4, '7879808182838485' + WORD $0x31383038 // .ascii 4, '8081828384858687' + WORD $0x33383238 // .ascii 4, '8283848586878889' + WORD $0x35383438 // .ascii 4, '8485868788899091' + WORD $0x37383638 // .ascii 4, '8687888990919293' + WORD $0x39383838 // .ascii 4, '8889909192939495' + WORD $0x31393039 // .ascii 4, '9091929394959697' + WORD $0x33393239 // .ascii 4, '9293949596979899' + WORD $0x35393439 // .ascii 4, '949596979899' + WORD $0x37393639 // .ascii 4, '96979899' + WORD $0x39393839 // .ascii 4, '9899' + WORD $0x00000000 // .p2align 4, 0x00 +_VecShiftShuffles: + WORD $0x03020100 // .ascii 4, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' + WORD $0x07060504 // .ascii 4, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x01\x02\x03\x04' + WORD $0x0b0a0908 // .ascii 4, '\x08\t\n\x0b\x0c\r\x0e\x0f\x01\x02\x03\x04\x05\x06\x07\x08' + WORD $0x0f0e0d0c // .ascii 4, '\x0c\r\x0e\x0f\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c' + WORD $0x04030201 // .ascii 4, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff' + WORD $0x08070605 // .ascii 4, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\x02\x03\x04\x05' + WORD $0x0c0b0a09 // .ascii 4, '\t\n\x0b\x0c\r\x0e\x0f\xff\x02\x03\x04\x05\x06\x07\x08\t' + WORD $0xff0f0e0d // .ascii 4, '\r\x0e\x0f\xff\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r' + WORD $0x05040302 // .ascii 4, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff' + WORD $0x09080706 // .ascii 4, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\x03\x04\x05\x06' + WORD $0x0d0c0b0a // .ascii 4, '\n\x0b\x0c\r\x0e\x0f\xff\xff\x03\x04\x05\x06\x07\x08\t\n' + WORD $0xffff0f0e // .ascii 4, '\x0e\x0f\xff\xff\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e' + WORD $0x06050403 // .ascii 4, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff' + WORD $0x0a090807 // .ascii 4, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\x04\x05\x06\x07' + WORD $0x0e0d0c0b // .ascii 4, '\x0b\x0c\r\x0e\x0f\xff\xff\xff\x04\x05\x06\x07\x08\t\n\x0b' + WORD $0xffffff0f // .ascii 4, '\x0f\xff\xff\xff\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' + WORD $0x07060504 // .ascii 4, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff' + WORD $0x0b0a0908 // .ascii 4, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\x05\x06\x07\x08' + WORD $0x0f0e0d0c // .ascii 4, '\x0c\r\x0e\x0f\xff\xff\xff\xff\x05\x06\x07\x08\t\n\x0b\x0c' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff' + WORD $0x08070605 // .ascii 4, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff' + WORD $0x0c0b0a09 // .ascii 4, '\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\x06\x07\x08\t' + WORD $0xff0f0e0d // .ascii 4, '\r\x0e\x0f\xff\xff\xff\xff\xff\x06\x07\x08\t\n\x0b\x0c\r' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff' + WORD $0x09080706 // .ascii 4, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff' + WORD $0x0d0c0b0a // .ascii 4, '\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\x07\x08\t\n' + WORD $0xffff0f0e // .ascii 4, '\x0e\x0f\xff\xff\xff\xff\xff\xff\x07\x08\t\n\x0b\x0c\r\x0e' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff' + WORD $0x0a090807 // .ascii 4, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff' + WORD $0x0e0d0c0b // .ascii 4, '\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\x08\t\n\x0b' + WORD $0xffffff0f // .ascii 4, '\x0f\xff\xff\xff\xff\xff\xff\xff\x08\t\n\x0b\x0c\r\x0e\x0f' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff' + WORD $0x0b0a0908 // .ascii 4, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff' + WORD $0x0f0e0d0c // .ascii 4, '\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff\xff\xff\xff\xff' + WORD $0xffffffff // .ascii 4, '\xff\xff\xff\xff' + +TEXT ·__u64toa(SB), $0-24 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $64, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_u64toa: + MOVD out+0(FP), R0 + MOVD val+8(FP), R1 + CALL ·__u64toa_arm64_entry__+76(SB) // _u64toa + MOVD R0, ret+16(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/u64toa_subr_arm64.go b/internal/native/neon/u64toa_subr_arm64.go new file mode 100644 index 000000000..01bae7a37 --- /dev/null +++ b/internal/native/neon/u64toa_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __u64toa_arm64_entry__() uintptr + +var ( + _subr__u64toa uintptr = __u64toa_arm64_entry__() + 64 +) + +const ( + _stack__u64toa = 32 +) + +var ( + _ = _subr__u64toa +) + +const ( + _ = _stack__u64toa +) diff --git a/internal/native/neon/unquote_arm64.go b/internal/native/neon/unquote_arm64.go new file mode 100644 index 000000000..204f95e60 --- /dev/null +++ b/internal/native/neon/unquote_arm64.go @@ -0,0 +1,37 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + `unsafe` + + // `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) { + return __unquote(sp, nb, dp, ep, flags) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) diff --git a/internal/native/neon/unquote_arm64.s b/internal/native/neon/unquote_arm64.s new file mode 100644 index 000000000..0ed8e5419 --- /dev/null +++ b/internal/native/neon/unquote_arm64.s @@ -0,0 +1,641 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__unquote_arm64_entry__(SB), NOSPLIT, $112 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910203ff // add sp, sp, #128 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_1: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_unquote: + MOVD.W R30, -128(RSP) // WORD $0xf8180ffe // str x30, [sp, #-128]! + WORD $0xa9026ffc // stp x28, x27, [sp, #32] + WORD $0xa90367fa // stp x26, x25, [sp, #48] + WORD $0xa9045ff8 // stp x24, x23, [sp, #64] + WORD $0xa90557f6 // stp x22, x21, [sp, #80] + WORD $0xa9064ff4 // stp x20, x19, [sp, #96] + WORD $0xa9077bfd // stp x29, x30, [sp, #112] + WORD $0xb4002161 // cbz x1, LBB0_62 $1068(%rip) + WORD $0x3203cbe9 // mov w9, #-522133280 + WORD $0x5299fa0a // mov w10, #53200 + WORD $0x72b9f9ea // movk w10, #53199, lsl #16 + WORD $0x3202c7eb // mov w11, #-1061109568 + WORD $0x3201c3ec // mov w12, #-2139062144 + WORD $0x3200dbed // mov w13, #2139062143 + WORD $0x5288c8ce // mov w14, #17990 + WORD $0x72a8c8ce // movk w14, #17990, lsl #16 + WORD $0x5287272f // mov w15, #14649 + WORD $0x72a7272f // movk w15, #14649, lsl #16 + WORD $0x52832330 // mov w16, #6425 + WORD $0x72a32330 // movk w16, #6425, lsl #16 + WORD $0x3200cff1 // mov w17, #252645135 + WORD $0x3200c3e6 // mov w6, #16843009 + WORD $0x92400085 // and x5, x4, #0x1 + WORD $0x528017b4 // mov w20, #189 + WORD $0x52848015 // mov w21, #9216 + WORD $0x72bf9415 // movk w21, #64672, lsl #16 + WORD $0x4f02e780 // movi.16b v0, #92 +Lloh0: + WORD $0x10fffba8 // adr x8, lCPI0_0 $-140(%rip) +Lloh1: + WORD $0x3dc00101 // ldr q1, [x8, lCPI0_0@PAGEOFF] $0(%rip) +Lloh2: + WORD $0x10fffbe8 // adr x8, lCPI0_1 $-132(%rip) +Lloh3: + WORD $0x3dc00102 // ldr q2, [x8, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0xaa0003e8 // mov x8, x0 + WORD $0xaa0103e7 // mov x7, x1 + WORD $0xaa0203f6 // mov x22, x2 +Lloh4: + WORD $0x100032d7 // adr x23, __UnquoteTab $1624(%rip) +Lloh5: + WORD $0x910002f7 // add x23, x23, __UnquoteTab@PAGEOFF $0(%rip) +LBB0_2: + WORD $0x39400118 // ldrb w24, [x8] + WORD $0x7101731f // cmp w24, #92 + WORD $0x54000061 // b.ne LBB0_4 $12(%rip) + WORD $0xd2800018 // mov x24, #0 + WORD $0x14000027 // b LBB0_15 $156(%rip) +LBB0_4: + WORD $0xaa0703f9 // mov x25, x7 + WORD $0xaa1603fb // mov x27, x22 + WORD $0xaa0803fa // mov x26, x8 + WORD $0xf10040ff // cmp x7, #16 + WORD $0x5400024b // b.lt LBB0_9 $72(%rip) + WORD $0xd2800018 // mov x24, #0 + WORD $0xaa0703fa // mov x26, x7 +LBB0_6: + WORD $0x3cf86903 // ldr q3, [x8, x24] + WORD $0x6e208c64 // cmeq.16b v4, v3, v0 + WORD $0x3cb86ac3 // str q3, [x22, x24] + WORD $0x4e211c83 // and.16b v3, v4, v1 + WORD $0x4e020063 // tbl.16b v3, { v3 }, v2 + WORD $0x4e71b863 // addv.8h h3, v3 + WORD $0x1e260079 // fmov w25, s3 + WORD $0x35000279 // cbnz w25, LBB0_13 $76(%rip) + WORD $0xd1004359 // sub x25, x26, #16 + WORD $0x91004318 // add x24, x24, #16 + WORD $0xf1007f5f // cmp x26, #31 + WORD $0xaa1903fa // mov x26, x25 + WORD $0x54fffe88 // b.hi LBB0_6 $-48(%rip) + WORD $0x8b18011a // add x26, x8, x24 + WORD $0x8b1802db // add x27, x22, x24 +LBB0_9: + WORD $0xb4001ab9 // cbz x25, LBB0_63 $852(%rip) + WORD $0xcb080358 // sub x24, x26, x8 +LBB0_11: + WORD $0x3940035c // ldrb w28, [x26] + WORD $0x7101739f // cmp w28, #92 + WORD $0x54000140 // b.eq LBB0_14 $40(%rip) + WORD $0x9100075a // add x26, x26, #1 + WORD $0x3800177c // strb w28, [x27], #1 + WORD $0x91000718 // add x24, x24, #1 + WORD $0xd1000739 // sub x25, x25, #1 + WORD $0xb5ffff39 // cbnz x25, LBB0_11 $-28(%rip) + WORD $0x140000cb // b LBB0_63 $812(%rip) +LBB0_13: + WORD $0x5ac00339 // rbit w25, w25 + WORD $0x5ac01339 // clz w25, w25 + WORD $0x8b180338 // add x24, x25, x24 +LBB0_14: + WORD $0xb100071f // cmn x24, #1 + WORD $0x540018c0 // b.eq LBB0_63 $792(%rip) +LBB0_15: + WORD $0x91000b19 // add x25, x24, #2 + WORD $0xeb1900e7 // subs x7, x7, x25 + WORD $0x54002c84 // b.mi LBB0_97 $1424(%rip) + WORD $0x8b190108 // add x8, x8, x25 + WORD $0xb5000145 // cbnz x5, LBB0_20 $40(%rip) + WORD $0x8b1802da // add x26, x22, x24 + WORD $0x385ff119 // ldurb w25, [x8, #-1] + WORD $0x38796af9 // ldrb w25, [x23, x25] + WORD $0x7103ff3f // cmp w25, #255 + WORD $0x540003a0 // b.eq LBB0_28 $116(%rip) +LBB0_18: + WORD $0x34002139 // cbz w25, LBB0_79 $1060(%rip) + WORD $0x38001759 // strb w25, [x26], #1 + WORD $0xaa1a03f6 // mov x22, x26 + WORD $0x14000092 // b LBB0_54 $584(%rip) +LBB0_20: + WORD $0x34002b07 // cbz w7, LBB0_97 $1376(%rip) + WORD $0x385ff119 // ldurb w25, [x8, #-1] + WORD $0x7101733f // cmp w25, #92 + WORD $0x54002801 // b.ne LBB0_90 $1280(%rip) + WORD $0x39400119 // ldrb w25, [x8] + WORD $0x7101733f // cmp w25, #92 + WORD $0x54000161 // b.ne LBB0_27 $44(%rip) + WORD $0x710004ff // cmp w7, #1 + WORD $0x54002a0d // b.le LBB0_97 $1344(%rip) + WORD $0xaa0803f9 // mov x25, x8 + WORD $0x38401f3a // ldrb w26, [x25, #1]! + WORD $0x71008b5f // cmp w26, #34 + WORD $0x54000060 // b.eq LBB0_26 $12(%rip) + WORD $0x7101735f // cmp w26, #92 + WORD $0x54002701 // b.ne LBB0_91 $1248(%rip) +LBB0_26: + WORD $0xd10004e7 // sub x7, x7, #1 + WORD $0xaa1903e8 // mov x8, x25 +LBB0_27: + WORD $0x91000508 // add x8, x8, #1 + WORD $0xd10004e7 // sub x7, x7, #1 + WORD $0x8b1802da // add x26, x22, x24 + WORD $0x385ff119 // ldurb w25, [x8, #-1] + WORD $0x38796af9 // ldrb w25, [x23, x25] + WORD $0x7103ff3f // cmp w25, #255 + WORD $0x54fffca1 // b.ne LBB0_18 $-108(%rip) +LBB0_28: + WORD $0xf1000cff // cmp x7, #3 + WORD $0x540027e9 // b.ls LBB0_97 $1276(%rip) + WORD $0xb9400119 // ldr w25, [x8] + WORD $0x0a39019b // bic w27, w12, w25 + WORD $0x0b0a033c // add w28, w25, w10 + WORD $0x0a1c037c // and w28, w27, w28 + WORD $0x7100039f // cmp w28, #0 + WORD $0x0b10033c // add w28, w25, w16 + WORD $0x2a19039c // orr w28, w28, w25 + WORD $0x0a0c039c // and w28, w28, w12 + WORD $0x7a400b80 // ccmp w28, #0, #0, eq + WORD $0x540013c1 // b.ne LBB0_65 $632(%rip) + WORD $0x0a0d033c // and w28, w25, w13 + WORD $0x0b0e039e // add w30, w28, w14 + WORD $0x4b1c0173 // sub w19, w11, w28 + WORD $0x0a130373 // and w19, w27, w19 + WORD $0x6a1e027f // tst w19, w30 + WORD $0x54001301 // b.ne LBB0_65 $608(%rip) + WORD $0x0b0f0393 // add w19, w28, w15 + WORD $0x4b1c013c // sub w28, w9, w28 + WORD $0x0a1c037b // and w27, w27, w28 + WORD $0x6a13037f // tst w27, w19 + WORD $0x54001261 // b.ne LBB0_65 $588(%rip) + WORD $0x5ac00b33 // rev w19, w25 + WORD $0x0a7310d9 // bic w25, w6, w19, lsr #4 + WORD $0x0b190f39 // add w25, w25, w25, lsl #3 + WORD $0x0a110273 // and w19, w19, w17 + WORD $0x0b130333 // add w19, w25, w19 + WORD $0x2a531273 // orr w19, w19, w19, lsr #4 + WORD $0x53087e79 // lsr w25, w19, #8 + WORD $0x12181f39 // and w25, w25, #0xff00 + WORD $0x33001e79 // bfxil w25, w19, #0, #8 + WORD $0x91001108 // add x8, x8, #4 + WORD $0xd10010e7 // sub x7, x7, #4 + WORD $0x7102033f // cmp w25, #128 + WORD $0x54000b03 // b.lo LBB0_55 $352(%rip) + WORD $0x8b1802d3 // add x19, x22, x24 + WORD $0x91000a76 // add x22, x19, #2 +LBB0_34: + WORD $0x711fff3f // cmp w25, #2047 + WORD $0x54000b09 // b.ls LBB0_57 $352(%rip) + WORD $0x51403b33 // sub w19, w25, #14, lsl #12 + WORD $0x3120067f // cmn w19, #2049 + WORD $0x540008c9 // b.ls LBB0_53 $280(%rip) + WORD $0xb50006c5 // cbnz x5, LBB0_48 $216(%rip) + WORD $0xaa0703f8 // mov x24, x7 + WORD $0xf1001b07 // subs x7, x24, #6 + WORD $0x5400078b // b.lt LBB0_51 $240(%rip) +LBB0_38: + WORD $0x530a7f33 // lsr w19, w25, #10 + WORD $0x7100da7f // cmp w19, #54 + WORD $0x54000728 // b.hi LBB0_51 $228(%rip) + WORD $0x39400113 // ldrb w19, [x8] + WORD $0x7101727f // cmp w19, #92 + WORD $0x540006c1 // b.ne LBB0_51 $216(%rip) + WORD $0x39400513 // ldrb w19, [x8, #1] + WORD $0x7101d67f // cmp w19, #117 + WORD $0x54000661 // b.ne LBB0_51 $204(%rip) + WORD $0xb8402118 // ldur w24, [x8, #2] + WORD $0x0b0a0313 // add w19, w24, w10 + WORD $0x0a38019a // bic w26, w12, w24 + WORD $0x6a13035f // tst w26, w19 + WORD $0x540016c1 // b.ne LBB0_80 $728(%rip) + WORD $0x0b100313 // add w19, w24, w16 + WORD $0x2a180273 // orr w19, w19, w24 + WORD $0x6a0c027f // tst w19, w12 + WORD $0x54001641 // b.ne LBB0_80 $712(%rip) + WORD $0x0a0d031b // and w27, w24, w13 + WORD $0x0b0e0373 // add w19, w27, w14 + WORD $0x4b1b017c // sub w28, w11, w27 + WORD $0x0a1c035c // and w28, w26, w28 + WORD $0x6a13039f // tst w28, w19 + WORD $0x54001581 // b.ne LBB0_80 $688(%rip) + WORD $0x0b0f0373 // add w19, w27, w15 + WORD $0x4b1b013b // sub w27, w9, w27 + WORD $0x0a1b035a // and w26, w26, w27 + WORD $0x6a13035f // tst w26, w19 + WORD $0x540014e1 // b.ne LBB0_80 $668(%rip) + WORD $0x5ac00b13 // rev w19, w24 + WORD $0x0a7310d8 // bic w24, w6, w19, lsr #4 + WORD $0x0b180f18 // add w24, w24, w24, lsl #3 + WORD $0x0a110273 // and w19, w19, w17 + WORD $0x0b130313 // add w19, w24, w19 + WORD $0x2a531273 // orr w19, w19, w19, lsr #4 + WORD $0x53087e78 // lsr w24, w19, #8 + WORD $0x12181f18 // and w24, w24, #0xff00 + WORD $0x33001e78 // bfxil w24, w19, #0, #8 + WORD $0x91001908 // add x8, x8, #6 + WORD $0x51403b13 // sub w19, w24, #14, lsl #12 + WORD $0x3110067f // cmn w19, #1025 + WORD $0x540005c8 // b.hi LBB0_58 $184(%rip) + WORD $0x36081b04 // tbz w4, #1, LBB0_92 $864(%rip) + WORD $0x5297fdf3 // mov w19, #49135 + WORD $0x781fe2d3 // sturh w19, [x22, #-2] + WORD $0x380036d4 // strb w20, [x22], #3 + WORD $0xaa1803f9 // mov x25, x24 + WORD $0x7102031f // cmp w24, #128 + WORD $0x54fff8e2 // b.hs LBB0_34 $-228(%rip) + WORD $0x14000036 // b LBB0_59 $216(%rip) +LBB0_48: + WORD $0xf10000ff // cmp x7, #0 + WORD $0x54001aed // b.le LBB0_95 $860(%rip) + WORD $0x39400113 // ldrb w19, [x8] + WORD $0x7101727f // cmp w19, #92 + WORD $0x54000661 // b.ne LBB0_60 $204(%rip) + WORD $0xd10004f8 // sub x24, x7, #1 + WORD $0x91000508 // add x8, x8, #1 + WORD $0xf1001b07 // subs x7, x24, #6 + WORD $0x54fff8ca // b.ge LBB0_38 $-232(%rip) +LBB0_51: + WORD $0x36081984 // tbz w4, #1, LBB0_94 $816(%rip) + WORD $0x5297fde7 // mov w7, #49135 + WORD $0x781fe2c7 // sturh w7, [x22, #-2] + WORD $0x380016d4 // strb w20, [x22], #1 + WORD $0xaa1803e7 // mov x7, x24 + WORD $0x1400000a // b LBB0_54 $40(%rip) +LBB0_53: + WORD $0x530c7f33 // lsr w19, w25, #12 + WORD $0x321b0a73 // orr w19, w19, #0xe0 + WORD $0x381fe2d3 // sturb w19, [x22, #-2] + WORD $0x52801013 // mov w19, #128 + WORD $0x33062f33 // bfxil w19, w25, #6, #6 + WORD $0x381ff2d3 // sturb w19, [x22, #-1] + WORD $0x52801013 // mov w19, #128 + WORD $0x33001733 // bfxil w19, w25, #0, #6 + WORD $0x380016d3 // strb w19, [x22], #1 +LBB0_54: + WORD $0xb5ffe6c7 // cbnz x7, LBB0_2 $-808(%rip) + WORD $0x14000025 // b LBB0_63 $148(%rip) +LBB0_55: + WORD $0xaa1903f8 // mov x24, x25 +LBB0_56: + WORD $0x38001758 // strb w24, [x26], #1 + WORD $0xaa1a03f6 // mov x22, x26 + WORD $0x17fffffb // b LBB0_54 $-20(%rip) +LBB0_57: + WORD $0x53067f33 // lsr w19, w25, #6 + WORD $0x321a0673 // orr w19, w19, #0xc0 + WORD $0x381fe2d3 // sturb w19, [x22, #-2] + WORD $0x52801013 // mov w19, #128 + WORD $0x33001733 // bfxil w19, w25, #0, #6 + WORD $0x381ff2d3 // sturb w19, [x22, #-1] + WORD $0x17fffff4 // b LBB0_54 $-48(%rip) +LBB0_58: + WORD $0x0b192b13 // add w19, w24, w25, lsl #10 + WORD $0x0b150278 // add w24, w19, w21 + WORD $0x53127f19 // lsr w25, w24, #18 + WORD $0x321c0f39 // orr w25, w25, #0xf0 + WORD $0x381fe2d9 // sturb w25, [x22, #-2] + WORD $0x52801019 // mov w25, #128 + WORD $0x330c4719 // bfxil w25, w24, #12, #6 + WORD $0x381ff2d9 // sturb w25, [x22, #-1] + WORD $0x52801019 // mov w25, #128 + WORD $0x33062f19 // bfxil w25, w24, #6, #6 + WORD $0x390002d9 // strb w25, [x22] + WORD $0x52801018 // mov w24, #128 + WORD $0x33001678 // bfxil w24, w19, #0, #6 + WORD $0x390006d8 // strb w24, [x22, #1] + WORD $0x91000ad6 // add x22, x22, #2 + WORD $0x17ffffe4 // b LBB0_54 $-112(%rip) +LBB0_59: + WORD $0xd1000ada // sub x26, x22, #2 + WORD $0x17ffffe5 // b LBB0_56 $-108(%rip) +LBB0_60: + WORD $0x36081324 // tbz w4, #1, LBB0_92 $612(%rip) + WORD $0x5297fdf3 // mov w19, #49135 + WORD $0x781fe2d3 // sturh w19, [x22, #-2] + WORD $0x380016d4 // strb w20, [x22], #1 + WORD $0x17ffffdd // b LBB0_54 $-140(%rip) +LBB0_62: + WORD $0xd2800007 // mov x7, #0 + WORD $0xaa0203f6 // mov x22, x2 +LBB0_63: + WORD $0x8b0702c8 // add x8, x22, x7 + WORD $0xcb020100 // sub x0, x8, x2 +LBB0_64: + WORD $0xa9477bfd // ldp x29, x30, [sp, #112] + WORD $0xa9464ff4 // ldp x20, x19, [sp, #96] + WORD $0xa94557f6 // ldp x22, x21, [sp, #80] + WORD $0xa9445ff8 // ldp x24, x23, [sp, #64] + WORD $0xa94367fa // ldp x26, x25, [sp, #48] + WORD $0xa9426ffc // ldp x28, x27, [sp, #32] + WORD $0x910203ff // add sp, sp, #128 + WORD $0xd65f03c0 // ret +LBB0_65: + WORD $0xcb000109 // sub x9, x8, x0 + WORD $0xf9000069 // str x9, [x3] + WORD $0x3940010a // ldrb w10, [x8] + WORD $0x5100e94b // sub w11, w10, #58 + WORD $0x12001d6b // and w11, w11, #0xff + WORD $0x7103d57f // cmp w11, #245 + WORD $0x54000148 // b.hi LBB0_68 $40(%rip) + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x92800020 // mov x0, #-2 + WORD $0x5101054a // sub w10, w10, #65 + WORD $0x7100955f // cmp w10, #37 + WORD $0x54fffda8 // b.hi LBB0_64 $-76(%rip) + WORD $0x5280002b // mov w11, #1 + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xf200155f // tst x10, #0x3f0000003f + WORD $0x54fffd20 // b.eq LBB0_64 $-92(%rip) +LBB0_68: + WORD $0x9100052a // add x10, x9, #1 + WORD $0xf900006a // str x10, [x3] + WORD $0x3940050a // ldrb w10, [x8, #1] + WORD $0x5100e94b // sub w11, w10, #58 + WORD $0x12001d6b // and w11, w11, #0xff + WORD $0x7103d57f // cmp w11, #245 + WORD $0x54000148 // b.hi LBB0_71 $40(%rip) + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x92800020 // mov x0, #-2 + WORD $0x5101054a // sub w10, w10, #65 + WORD $0x7100955f // cmp w10, #37 + WORD $0x54fffba8 // b.hi LBB0_64 $-140(%rip) + WORD $0x5280002b // mov w11, #1 + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xf200155f // tst x10, #0x3f0000003f + WORD $0x54fffb20 // b.eq LBB0_64 $-156(%rip) +LBB0_71: + WORD $0x9100092a // add x10, x9, #2 + WORD $0xf900006a // str x10, [x3] + WORD $0x3940090a // ldrb w10, [x8, #2] + WORD $0x5100e94b // sub w11, w10, #58 + WORD $0x12001d6b // and w11, w11, #0xff + WORD $0x7103d57f // cmp w11, #245 + WORD $0x54000148 // b.hi LBB0_74 $40(%rip) + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x92800020 // mov x0, #-2 + WORD $0x5101054a // sub w10, w10, #65 + WORD $0x7100955f // cmp w10, #37 + WORD $0x54fff9a8 // b.hi LBB0_64 $-204(%rip) + WORD $0x5280002b // mov w11, #1 + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xf200155f // tst x10, #0x3f0000003f + WORD $0x54fff920 // b.eq LBB0_64 $-220(%rip) +LBB0_74: + WORD $0x91000d2a // add x10, x9, #3 + WORD $0xf900006a // str x10, [x3] + WORD $0x39400d08 // ldrb w8, [x8, #3] + WORD $0x5100e90a // sub w10, w8, #58 + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x7103d55f // cmp w10, #245 + WORD $0x54000148 // b.hi LBB0_77 $40(%rip) +LBB0_75: + WORD $0x12001d08 // and w8, w8, #0xff + WORD $0x92800020 // mov x0, #-2 + WORD $0x51010508 // sub w8, w8, #65 + WORD $0x7100951f // cmp w8, #37 + WORD $0x54fff7a8 // b.hi LBB0_64 $-268(%rip) + WORD $0x5280002a // mov w10, #1 + WORD $0x9ac82148 // lsl x8, x10, x8 + WORD $0xf200151f // tst x8, #0x3f0000003f + WORD $0x54fff720 // b.eq LBB0_64 $-284(%rip) +LBB0_77: + WORD $0x91001128 // add x8, x9, #4 +LBB0_78: + WORD $0xf9000068 // str x8, [x3] + WORD $0x92800020 // mov x0, #-2 + WORD $0x17ffffb5 // b LBB0_64 $-300(%rip) +LBB0_79: + WORD $0xaa2003e9 // mvn x9, x0 + WORD $0x8b090108 // add x8, x8, x9 + WORD $0xf9000068 // str x8, [x3] + WORD $0x92800040 // mov x0, #-3 + WORD $0x17ffffb0 // b LBB0_64 $-320(%rip) +LBB0_80: + WORD $0xcb000109 // sub x9, x8, x0 + WORD $0x91000929 // add x9, x9, #2 + WORD $0xf9000069 // str x9, [x3] + WORD $0x3940090a // ldrb w10, [x8, #2] + WORD $0x5100e94b // sub w11, w10, #58 + WORD $0x12001d6b // and w11, w11, #0xff + WORD $0x7103d57f // cmp w11, #245 + WORD $0x54000148 // b.hi LBB0_83 $40(%rip) + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x92800020 // mov x0, #-2 + WORD $0x5101054a // sub w10, w10, #65 + WORD $0x7100955f // cmp w10, #37 + WORD $0x54fff468 // b.hi LBB0_64 $-372(%rip) + WORD $0x5280002b // mov w11, #1 + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xf200155f // tst x10, #0x3f0000003f + WORD $0x54fff3e0 // b.eq LBB0_64 $-388(%rip) +LBB0_83: + WORD $0x9100052a // add x10, x9, #1 + WORD $0xf900006a // str x10, [x3] + WORD $0x39400d0a // ldrb w10, [x8, #3] + WORD $0x5100e94b // sub w11, w10, #58 + WORD $0x12001d6b // and w11, w11, #0xff + WORD $0x7103d57f // cmp w11, #245 + WORD $0x54000148 // b.hi LBB0_86 $40(%rip) + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x92800020 // mov x0, #-2 + WORD $0x5101054a // sub w10, w10, #65 + WORD $0x7100955f // cmp w10, #37 + WORD $0x54fff268 // b.hi LBB0_64 $-436(%rip) + WORD $0x5280002b // mov w11, #1 + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xf200155f // tst x10, #0x3f0000003f + WORD $0x54fff1e0 // b.eq LBB0_64 $-452(%rip) +LBB0_86: + WORD $0x9100092a // add x10, x9, #2 + WORD $0xf900006a // str x10, [x3] + WORD $0x3940110a // ldrb w10, [x8, #4] + WORD $0x5100e94b // sub w11, w10, #58 + WORD $0x12001d6b // and w11, w11, #0xff + WORD $0x7103d57f // cmp w11, #245 + WORD $0x54000148 // b.hi LBB0_89 $40(%rip) + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x92800020 // mov x0, #-2 + WORD $0x5101054a // sub w10, w10, #65 + WORD $0x7100955f // cmp w10, #37 + WORD $0x54fff068 // b.hi LBB0_64 $-500(%rip) + WORD $0x5280002b // mov w11, #1 + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xf200155f // tst x10, #0x3f0000003f + WORD $0x54ffefe0 // b.eq LBB0_64 $-516(%rip) +LBB0_89: + WORD $0x91000d2a // add x10, x9, #3 + WORD $0xf900006a // str x10, [x3] + WORD $0x39401508 // ldrb w8, [x8, #5] + WORD $0x5100e90a // sub w10, w8, #58 + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x7103d55f // cmp w10, #245 + WORD $0x54fff6e9 // b.ls LBB0_75 $-292(%rip) + WORD $0x17ffffbf // b LBB0_77 $-260(%rip) +LBB0_90: + WORD $0xaa2003e9 // mvn x9, x0 + WORD $0x8b090108 // add x8, x8, x9 + WORD $0x17ffffbd // b LBB0_78 $-268(%rip) +LBB0_91: + WORD $0xcb000108 // sub x8, x8, x0 + WORD $0x91000508 // add x8, x8, #1 + WORD $0x17ffffba // b LBB0_78 $-280(%rip) +LBB0_92: + WORD $0xcb000108 // sub x8, x8, x0 +LBB0_93: + WORD $0xd1001108 // sub x8, x8, #4 + WORD $0xf9000068 // str x8, [x3] + WORD $0x92800060 // mov x0, #-4 + WORD $0x17ffff6c // b LBB0_64 $-592(%rip) +LBB0_94: + WORD $0x8b0000a9 // add x9, x5, x0 + WORD $0xcb090108 // sub x8, x8, x9 + WORD $0x17fffffa // b LBB0_93 $-24(%rip) +LBB0_95: + WORD $0x360800e4 // tbz w4, #1, LBB0_97 $28(%rip) + WORD $0xd2800007 // mov x7, #0 + WORD $0x5297fde8 // mov w8, #49135 + WORD $0x781fe2c8 // sturh w8, [x22, #-2] + WORD $0x528017a8 // mov w8, #189 + WORD $0x380016c8 // strb w8, [x22], #1 + WORD $0x17ffff60 // b LBB0_63 $-640(%rip) +LBB0_97: + WORD $0xf9000061 // str x1, [x3] + WORD $0x92800000 // mov x0, #-1 + WORD $0x17ffff5f // b LBB0_64 $-644(%rip) +__UnquoteTab: + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00220000 // .ascii 4, '\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00/\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x2f000000 // .ascii 4, '\x00\x00\x00/\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00\x00\x00\x08\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\\\x00\x00\x00\x00\x00\x08\x00\x00\x00\x0c\x00' + WORD $0x0000005c // .ascii 4, '\\\x00\x00\x00\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00' + WORD $0x00080000 // .ascii 4, '\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00' + WORD $0x000c0000 // .ascii 4, '\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\r\x00' + WORD $0x00000000 // .ascii 4, '\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\r\x00\t\xff\x00\x00' + WORD $0x000a0000 // .ascii 4, '\x00\x00\n\x00\x00\x00\r\x00\t\xff\x00\x00' + WORD $0x000d0000 // .ascii 4, '\x00\x00\r\x00\t\xff\x00\x00' + WORD $0x0000ff09 // .ascii 4, '\t\xff\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + +TEXT ·__unquote(SB), $0-48 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $160, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_unquote: + MOVD sp+0(FP), R0 + MOVD nb+8(FP), R1 + MOVD dp+16(FP), R2 + MOVD ep+24(FP), R3 + MOVD flags+32(FP), R4 + CALL ·__unquote_arm64_entry__+60(SB) // _unquote + MOVD R0, ret+40(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/unquote_subr_arm64.go b/internal/native/neon/unquote_subr_arm64.go new file mode 100644 index 000000000..41af7a71d --- /dev/null +++ b/internal/native/neon/unquote_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __unquote_arm64_entry__() uintptr + +var ( + _subr__unquote uintptr = __unquote_arm64_entry__() + 48 +) + +const ( + _stack__unquote = 128 +) + +var ( + _ = _subr__unquote +) + +const ( + _ = _stack__unquote +) diff --git a/internal/native/neon/validate_one_arm64.go b/internal/native/neon/validate_one_arm64.go new file mode 100644 index 000000000..14a6dad3e --- /dev/null +++ b/internal/native/neon/validate_one_arm64.go @@ -0,0 +1,37 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + // `unsafe` + + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func validate_one(s *string, p *int, m *types.StateMachine) (ret int) { + return __validate_one(s, p, m) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_one(s *string, p *int, m *types.StateMachine) (ret int) diff --git a/internal/native/neon/validate_one_arm64.s b/internal/native/neon/validate_one_arm64.s new file mode 100644 index 000000000..9c84f3549 --- /dev/null +++ b/internal/native/neon/validate_one_arm64.s @@ -0,0 +1,2076 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__validate_one_arm64_entry__(SB), NOSPLIT, $144 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910283ff // add sp, sp, #160 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x00000001; WORD $0x00000000 // .quad 1 + WORD $0x00000000; WORD $0x00000000 // .quad 0 +lCPI0_1: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_2: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_validate_one: + MOVD.W R30, -160(RSP) // WORD $0xf8160ffe // str x30, [sp, #-160]! + WORD $0xa9046ffc // stp x28, x27, [sp, #64] + WORD $0xa90567fa // stp x26, x25, [sp, #80] + WORD $0xa9065ff8 // stp x24, x23, [sp, #96] + WORD $0xa90757f6 // stp x22, x21, [sp, #112] + WORD $0xa9084ff4 // stp x20, x19, [sp, #128] + WORD $0xa9097bfd // stp x29, x30, [sp, #144] + WORD $0xaa0003e3 // mov x3, x0 +Lloh0: + WORD $0x10fffd88 // adr x8, lCPI0_0 $-80(%rip) +Lloh1: + WORD $0x3dc00100 // ldr q0, [x8, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x3d800040 // str q0, [x2] + WORD $0xf9400009 // ldr x9, [x0] + WORD $0xaa2903e8 // mvn x8, x9 + WORD $0xf90013e8 // str x8, [sp, #32] + WORD $0x5280002b // mov w11, #1 + WORD $0xcb090168 // sub x8, x11, x9 + WORD $0xf90017e8 // str x8, [sp, #40] + WORD $0xf9400020 // ldr x0, [x1] + WORD $0xcb0903e8 // neg x8, x9 + WORD $0xf9001be8 // str x8, [sp, #48] + WORD $0xd1000528 // sub x8, x9, #1 + WORD $0xf9001fe8 // str x8, [sp, #56] + WORD $0x92800004 // mov x4, #-1 + WORD $0xd284c010 // mov x16, #9728 + WORD $0xf2c00030 // movk x16, #1, lsl #32 +Lloh2: + WORD $0x1000bcae // adr x14, LJTI0_1 $6036(%rip) +Lloh3: + WORD $0x910001ce // add x14, x14, LJTI0_1@PAGEOFF $0(%rip) + WORD $0x4f01e440 // movi.16b v0, #34 +Lloh4: + WORD $0x10fffb88 // adr x8, lCPI0_1 $-144(%rip) +Lloh5: + WORD $0x3dc00101 // ldr q1, [x8, lCPI0_1@PAGEOFF] $0(%rip) +Lloh6: + WORD $0x10fffbc8 // adr x8, lCPI0_2 $-136(%rip) +Lloh7: + WORD $0x3dc00102 // ldr q2, [x8, lCPI0_2@PAGEOFF] $0(%rip) + WORD $0x4f02e783 // movi.16b v3, #92 + WORD $0x4f01e404 // movi.16b v4, #32 + WORD $0x52800046 // mov w6, #2 + WORD $0x4f01e5c5 // movi.16b v5, #46 + WORD $0x4f01e566 // movi.16b v6, #43 +Lloh8: + WORD $0x1000c2f3 // adr x19, LJTI0_2 $6236(%rip) +Lloh9: + WORD $0x91000273 // add x19, x19, LJTI0_2@PAGEOFF $0(%rip) + WORD $0x12800014 // mov w20, #-1 + WORD $0x4f01e5a7 // movi.16b v7, #45 + WORD $0x4f06e610 // movi.16b v16, #208 +Lloh10: + WORD $0x1000c335 // adr x21, LJTI0_3 $6244(%rip) +Lloh11: + WORD $0x910002b5 // add x21, x21, LJTI0_3@PAGEOFF $0(%rip) + WORD $0x4f00e551 // movi.16b v17, #10 + WORD $0x4f06e7f2 // movi.16b v18, #223 + WORD $0x4f02e4b3 // movi.16b v19, #69 + WORD $0x52800037 // mov w23, #1 +Lloh12: + WORD $0x1000b97e // adr x30, LJTI0_0 $5932(%rip) +Lloh13: + WORD $0x910003de // add x30, x30, LJTI0_0@PAGEOFF $0(%rip) + WORD $0x1400000c // b LBB0_5 $48(%rip) +LBB0_1: + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x5400a8cc // b.gt LBB0_283 $5400(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x528000ca // mov w10, #6 +LBB0_3: + WORD $0xf900050a // str x10, [x8, #8] +LBB0_4: + WORD $0xf9400057 // ldr x23, [x2] + WORD $0xaa0403ef // mov x15, x4 + WORD $0xb400a957 // cbz x23, LBB0_290 $5416(%rip) +LBB0_5: + WORD $0xf940046f // ldr x15, [x3, #8] + WORD $0xeb0f001f // cmp x0, x15 + WORD $0x54000162 // b.hs LBB0_10 $44(%rip) + WORD $0x38606928 // ldrb w8, [x9, x0] + WORD $0x7100351f // cmp w8, #13 + WORD $0x54000100 // b.eq LBB0_10 $32(%rip) + WORD $0x7100811f // cmp w8, #32 + WORD $0x540000c0 // b.eq LBB0_10 $24(%rip) + WORD $0x51002d08 // sub w8, w8, #11 + WORD $0x3100091f // cmn w8, #2 + WORD $0x54000062 // b.hs LBB0_10 $12(%rip) + WORD $0xaa0003e8 // mov x8, x0 + WORD $0x14000035 // b LBB0_30 $212(%rip) +LBB0_10: + WORD $0x91000408 // add x8, x0, #1 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_14 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_14 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_14 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x54000543 // b.lo LBB0_30 $168(%rip) +LBB0_14: + WORD $0x91000808 // add x8, x0, #2 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_18 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_18 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_18 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x540003e3 // b.lo LBB0_30 $124(%rip) +LBB0_18: + WORD $0x91000c08 // add x8, x0, #3 + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54000122 // b.hs LBB0_22 $36(%rip) + WORD $0x3868692a // ldrb w10, [x9, x8] + WORD $0x7100355f // cmp w10, #13 + WORD $0x540000c0 // b.eq LBB0_22 $24(%rip) + WORD $0x7100815f // cmp w10, #32 + WORD $0x54000080 // b.eq LBB0_22 $16(%rip) + WORD $0x51002d4a // sub w10, w10, #11 + WORD $0x3100095f // cmn w10, #2 + WORD $0x54000283 // b.lo LBB0_30 $80(%rip) +LBB0_22: + WORD $0x91001008 // add x8, x0, #4 + WORD $0xeb0801ff // cmp x15, x8 + WORD $0x5400a149 // b.ls LBB0_281 $5160(%rip) + WORD $0x54000180 // b.eq LBB0_27 $48(%rip) + WORD $0x8b0f012a // add x10, x9, x15 +LBB0_25: + WORD $0x38e8692c // ldrsb w12, [x9, x8] + WORD $0x7100819f // cmp w12, #32 + WORD $0x9acc216c // lsl x12, x11, x12 + WORD $0x8a10018c // and x12, x12, x16 + WORD $0xfa409984 // ccmp x12, #0, #4, ls + WORD $0x540000e0 // b.eq LBB0_29 $28(%rip) + WORD $0x91000508 // add x8, x8, #1 + WORD $0xeb0801ff // cmp x15, x8 + WORD $0x54ffff01 // b.ne LBB0_25 $-32(%rip) + WORD $0x14000002 // b LBB0_28 $8(%rip) +LBB0_27: + WORD $0x8b08012a // add x10, x9, x8 +LBB0_28: + WORD $0xcb090148 // sub x8, x10, x9 +LBB0_29: + WORD $0xeb0f011f // cmp x8, x15 + WORD $0x54009f62 // b.hs LBB0_282 $5100(%rip) +LBB0_30: + WORD $0x91000500 // add x0, x8, #1 + WORD $0xf9000020 // str x0, [x1] + WORD $0x8b08013b // add x27, x9, x8 + WORD $0x39c00367 // ldrsb w7, [x27] + WORD $0x34009ec7 // cbz w7, LBB0_282 $5080(%rip) + WORD $0xd10006e5 // sub x5, x23, #1 + WORD $0x8b050c4a // add x10, x2, x5, lsl #3 + WORD $0xb8408d4c // ldr w12, [x10, #8]! + WORD $0xb100049f // cmn x4, #1 + WORD $0x9a840104 // csel x4, x8, x4, eq + WORD $0x5100058c // sub w12, w12, #1 + WORD $0x7100159f // cmp w12, #5 + WORD $0x54000148 // b.hi LBB0_35 $40(%rip) + WORD $0x1000008d // adr x13, LBB0_33 $16(%rip) + WORD $0x786c7bcf // ldrh w15, [x30, x12, lsl #1] + WORD $0x8b0f09ad // add x13, x13, x15, lsl #2 + WORD $0xd61f01a0 // br x13 +LBB0_33: + WORD $0x7100b0ff // cmp w7, #44 + WORD $0x54002660 // b.eq LBB0_93 $1228(%rip) + WORD $0x710174ff // cmp w7, #93 + WORD $0x540023a0 // b.eq LBB0_88 $1140(%rip) + WORD $0x140004f2 // b LBB0_289 $5064(%rip) +LBB0_35: + WORD $0xf9000045 // str x5, [x2] + WORD $0x7101ecff // cmp w7, #123 + WORD $0x54001109 // b.ls LBB0_54 $544(%rip) + WORD $0x140004ee // b LBB0_289 $5048(%rip) +LBB0_36: + WORD $0x7100b0ff // cmp w7, #44 + WORD $0x54002281 // b.ne LBB0_87 $1104(%rip) + WORD $0xf13ffeff // cmp x23, #4095 + WORD $0x54009bec // b.gt LBB0_283 $4988(%rip) + WORD $0x910006e8 // add x8, x23, #1 + WORD $0xf9000048 // str x8, [x2] + WORD $0x8b170c48 // add x8, x2, x23, lsl #3 + WORD $0x5280006a // mov w10, #3 + WORD $0x17ffff99 // b LBB0_3 $-412(%rip) +LBB0_39: + WORD $0x710088ff // cmp w7, #34 + WORD $0x54009c61 // b.ne LBB0_289 $5004(%rip) + WORD $0x5280008c // mov w12, #4 + WORD $0xf900014c // str x12, [x10] + WORD $0xf940046f // ldr x15, [x3, #8] + WORD $0xeb0001f8 // subs x24, x15, x0 + WORD $0x5400a820 // b.eq LBB0_318 $5380(%rip) + WORD $0xf101031f // cmp x24, #64 + WORD $0x54008843 // b.lo LBB0_260 $4360(%rip) + WORD $0xd2800017 // mov x23, #0 + WORD $0x92800016 // mov x22, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_43: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260305 // fmov w5, s24 + WORD $0x6e238ef8 // cmeq.16b v24, v23, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031a // fmov w26, s24 + WORD $0x6e238ed8 // cmeq.16b v24, v22, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031b // fmov w27, s24 + WORD $0x6e238eb8 // cmeq.16b v24, v21, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0x6e238e98 // cmeq.16b v24, v20, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503cad // bfi x13, x5, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0187 // orr x7, x12, x10 + WORD $0xd3607f8a // lsl x10, x28, #32 + WORD $0xb3503e2a // bfi x10, x17, #48, #16 + WORD $0x53103f6c // lsl w12, w27, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa1a014a // orr x10, x10, x26 + WORD $0xb500044a // cbnz x10, LBB0_48 $136(%rip) + WORD $0xb50004f7 // cbnz x23, LBB0_49 $156(%rip) +LBB0_45: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503e2d // bfi x13, x17, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb50016e7 // cbnz x7, LBB0_89 $732(%rip) + WORD $0xb50092ca // cbnz x10, LBB0_293 $4696(%rip) + WORD $0xd1010318 // sub x24, x24, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff1f // cmp x24, #63 + WORD $0x54fff568 // b.hi LBB0_43 $-340(%rip) + WORD $0x140002c4 // b LBB0_198 $2832(%rip) +LBB0_48: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c12d6 // csel x22, x22, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_49: + WORD $0x8a37014c // bic x12, x10, x23 + WORD $0xaa0c06ed // orr x13, x23, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a00e7 // bic x7, x7, x10 + WORD $0x17ffffd0 // b LBB0_45 $-192(%rip) +LBB0_50: + WORD $0x7100e8ff // cmp w7, #58 + WORD $0x54008de1 // b.ne LBB0_289 $4540(%rip) + WORD $0xf900015f // str xzr, [x10] + WORD $0x17ffff22 // b LBB0_4 $-888(%rip) +LBB0_52: + WORD $0x710174ff // cmp w7, #93 + WORD $0x540012a0 // b.eq LBB0_88 $596(%rip) + WORD $0xf900014b // str x11, [x10] + WORD $0x7101ecff // cmp w7, #123 + WORD $0x54008d08 // b.hi LBB0_289 $4512(%rip) +LBB0_54: + WORD $0x9280000f // mov x15, #-1 + WORD $0x10ffe26a // adr x10, LBB0_1 $-948(%rip) + WORD $0x786779cc // ldrh w12, [x14, x7, lsl #1] + WORD $0x8b0c094a // add x10, x10, x12, lsl #2 + WORD $0xd61f0140 // br x10 +LBB0_55: + WORD $0xf940046a // ldr x10, [x3, #8] + WORD $0xeb080156 // subs x22, x10, x8 + WORD $0x54008b80 // b.eq LBB0_286 $4464(%rip) + WORD $0x3940036a // ldrb w10, [x27] + WORD $0x7100c15f // cmp w10, #48 + WORD $0x54000181 // b.ne LBB0_60 $48(%rip) + WORD $0xf10006df // cmp x22, #1 + WORD $0x540027c0 // b.eq LBB0_124 $1272(%rip) + WORD $0x3860692a // ldrb w10, [x9, x0] + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x54002748 // b.hi LBB0_124 $1256(%rip) + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xb20903ec // mov x12, #36028797027352576 + WORD $0xf280002c // movk x12, #1 + WORD $0xea0c015f // tst x10, x12 + WORD $0x540026a0 // b.eq LBB0_124 $1236(%rip) +LBB0_60: + WORD $0xf10042df // cmp x22, #16 + WORD $0x540078e3 // b.lo LBB0_263 $3868(%rip) + WORD $0xd280001a // mov x26, #0 + WORD $0x92800017 // mov x23, #-1 + WORD $0x92800000 // mov x0, #-1 + WORD $0x9280000f // mov x15, #-1 + WORD $0xaa1603f8 // mov x24, x22 +LBB0_62: + WORD $0x3cfa6b74 // ldr q20, [x27, x26] + WORD $0x6e258e95 // cmeq.16b v21, v20, v5 + WORD $0x6e268e96 // cmeq.16b v22, v20, v6 + WORD $0x6e278e97 // cmeq.16b v23, v20, v7 + WORD $0x4e308698 // add.16b v24, v20, v16 + WORD $0x6e383638 // cmhi.16b v24, v17, v24 + WORD $0x4e321e94 // and.16b v20, v20, v18 + WORD $0x6e338e94 // cmeq.16b v20, v20, v19 + WORD $0x4eb61ef6 // orr.16b v22, v23, v22 + WORD $0x4eb51e97 // orr.16b v23, v20, v21 + WORD $0x4eb61ef7 // orr.16b v23, v23, v22 + WORD $0x4eb81ef7 // orr.16b v23, v23, v24 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x4e211ed4 // and.16b v20, v22, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x4e211ef4 // and.16b v20, v23, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x2a3103f1 // mvn w17, w17 + WORD $0x32103e31 // orr w17, w17, #0xffff0000 + WORD $0x5ac00231 // rbit w17, w17 + WORD $0x5ac01227 // clz w7, w17 + WORD $0x1ac72291 // lsl w17, w20, w7 + WORD $0x0a310145 // bic w5, w10, w17 + WORD $0x0a310199 // bic w25, w12, w17 + WORD $0x0a3101b1 // bic w17, w13, w17 + WORD $0x710040ff // cmp w7, #16 + WORD $0x1a85014a // csel w10, w10, w5, eq + WORD $0x1a990199 // csel w25, w12, w25, eq + WORD $0x1a9101a5 // csel w5, w13, w17, eq + WORD $0x5100054c // sub w12, w10, #1 + WORD $0x6a0a018c // ands w12, w12, w10 + WORD $0x54005281 // b.ne LBB0_204 $2640(%rip) + WORD $0x5100072c // sub w12, w25, #1 + WORD $0x6a19018c // ands w12, w12, w25 + WORD $0x54005221 // b.ne LBB0_204 $2628(%rip) + WORD $0x510004ac // sub w12, w5, #1 + WORD $0x6a05018c // ands w12, w12, w5 + WORD $0x540051c1 // b.ne LBB0_204 $2616(%rip) + WORD $0x340000ca // cbz w10, LBB0_68 $24(%rip) + WORD $0x5ac0014a // rbit w10, w10 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb10005ff // cmn x15, #1 + WORD $0x54005281 // b.ne LBB0_208 $2640(%rip) + WORD $0x8b0a034f // add x15, x26, x10 +LBB0_68: + WORD $0x340000d9 // cbz w25, LBB0_71 $24(%rip) + WORD $0x5ac0032a // rbit w10, w25 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb100041f // cmn x0, #1 + WORD $0x540051c1 // b.ne LBB0_208 $2616(%rip) + WORD $0x8b0a0340 // add x0, x26, x10 +LBB0_71: + WORD $0x340000c5 // cbz w5, LBB0_74 $24(%rip) + WORD $0x5ac000aa // rbit w10, w5 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb10006ff // cmn x23, #1 + WORD $0x54005101 // b.ne LBB0_208 $2592(%rip) + WORD $0x8b0a0357 // add x23, x26, x10 +LBB0_74: + WORD $0x710040ff // cmp w7, #16 + WORD $0x54001a41 // b.ne LBB0_111 $840(%rip) + WORD $0xd1004318 // sub x24, x24, #16 + WORD $0x9100435a // add x26, x26, #16 + WORD $0xf1003f1f // cmp x24, #15 + WORD $0x54fff708 // b.hi LBB0_62 $-288(%rip) + WORD $0x8b1a0379 // add x25, x27, x26 + WORD $0xeb1a02df // cmp x22, x26 + WORD $0x540019a0 // b.eq LBB0_112 $820(%rip) +LBB0_77: + WORD $0x8b180325 // add x5, x25, x24 + WORD $0xf9401fea // ldr x10, [sp, #56] + WORD $0x8b08014a // add x10, x10, x8 + WORD $0xcb190147 // sub x7, x10, x25 + WORD $0xcb1b033a // sub x26, x25, x27 + WORD $0xaa1903f6 // mov x22, x25 + WORD $0x1400000b // b LBB0_81 $44(%rip) +LBB0_78: + WORD $0x7101955f // cmp w10, #101 + WORD $0x54001881 // b.ne LBB0_112 $784(%rip) +LBB0_79: + WORD $0xb100041f // cmn x0, #1 + WORD $0xaa1a03e0 // mov x0, x26 + WORD $0x54001a81 // b.ne LBB0_122 $848(%rip) +LBB0_80: + WORD $0xd10004e7 // sub x7, x7, #1 + WORD $0x9100075a // add x26, x26, #1 + WORD $0xaa1603f9 // mov x25, x22 + WORD $0xd1000718 // sub x24, x24, #1 + WORD $0xb4003258 // cbz x24, LBB0_155 $1608(%rip) +LBB0_81: + WORD $0x38c016ca // ldrsb w10, [x22], #1 + WORD $0x5100c14c // sub w12, w10, #48 + WORD $0x7100299f // cmp w12, #10 + WORD $0x54ffff03 // b.lo LBB0_80 $-32(%rip) + WORD $0x5100ad4c // sub w12, w10, #43 + WORD $0x7100699f // cmp w12, #26 + WORD $0x54fffe08 // b.hi LBB0_78 $-64(%rip) + WORD $0x10fffe2a // adr x10, LBB0_79 $-60(%rip) + WORD $0x386c6aad // ldrb w13, [x21, x12] + WORD $0x8b0d094a // add x10, x10, x13, lsl #2 + WORD $0xd61f0140 // br x10 +LBB0_84: + WORD $0xb10006ff // cmn x23, #1 + WORD $0xaa1a03f7 // mov x23, x26 + WORD $0x54fffdc0 // b.eq LBB0_80 $-72(%rip) + WORD $0x140000c0 // b LBB0_122 $768(%rip) +LBB0_85: + WORD $0xb10005ff // cmn x15, #1 + WORD $0xaa1a03ef // mov x15, x26 + WORD $0x54fffd40 // b.eq LBB0_80 $-88(%rip) + WORD $0x140000bc // b LBB0_122 $752(%rip) +LBB0_86: + WORD $0x710088ff // cmp w7, #34 + WORD $0x540003c0 // b.eq LBB0_95 $120(%rip) +LBB0_87: + WORD $0x7101f4ff // cmp w7, #125 + WORD $0x54007ae1 // b.ne LBB0_289 $3932(%rip) +LBB0_88: + WORD $0xf9000045 // str x5, [x2] + WORD $0xaa0503f7 // mov x23, x5 + WORD $0xaa0403ef // mov x15, x4 + WORD $0xb5ffd165 // cbnz x5, LBB0_5 $-1492(%rip) + WORD $0x140003d3 // b LBB0_290 $3916(%rip) +LBB0_89: + WORD $0xdac000ec // rbit x12, x7 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54008623 // b.lo LBB0_319 $4292(%rip) + WORD $0x8b00018a // add x10, x12, x0 + WORD $0x91000540 // add x0, x10, #1 +LBB0_91: + WORD $0xb7f87800 // tbnz x0, #63, LBB0_284 $3840(%rip) +LBB0_92: + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb27ff7ea // mov x10, #9223372036854775806 + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x54ffcf29 // b.ls LBB0_4 $-1564(%rip) + WORD $0x140003c4 // b LBB0_290 $3856(%rip) +LBB0_93: + WORD $0xf13ffeff // cmp x23, #4095 + WORD $0x540076cc // b.gt LBB0_283 $3800(%rip) + WORD $0x910006e8 // add x8, x23, #1 + WORD $0xf9000048 // str x8, [x2] + WORD $0x8b170c48 // add x8, x2, x23, lsl #3 + WORD $0xf900051f // str xzr, [x8, #8] + WORD $0x17fffe71 // b LBB0_4 $-1596(%rip) +LBB0_95: + WORD $0xf9000146 // str x6, [x10] + WORD $0xf9400476 // ldr x22, [x3, #8] + WORD $0xeb0002d8 // subs x24, x22, x0 + WORD $0x540083e0 // b.eq LBB0_320 $4220(%rip) + WORD $0xf101031f // cmp x24, #64 + WORD $0x540066e3 // b.lo LBB0_265 $3292(%rip) + WORD $0xd2800017 // mov x23, #0 + WORD $0x9280000f // mov x15, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_98: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e238ef8 // cmeq.16b v24, v23, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260305 // fmov w5, s24 + WORD $0x6e238ed8 // cmeq.16b v24, v22, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031a // fmov w26, s24 + WORD $0x6e238eb8 // cmeq.16b v24, v21, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031b // fmov w27, s24 + WORD $0x6e238e98 // cmeq.16b v24, v20, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031c // fmov w28, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503e2d // bfi x13, x17, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0187 // orr x7, x12, x10 + WORD $0xd3607f6a // lsl x10, x27, #32 + WORD $0xb3503f8a // bfi x10, x28, #48, #16 + WORD $0x53103f4c // lsl w12, w26, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa05014a // orr x10, x10, x5 + WORD $0xb500044a // cbnz x10, LBB0_103 $136(%rip) + WORD $0xb50004f7 // cbnz x23, LBB0_104 $156(%rip) +LBB0_100: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503e2d // bfi x13, x17, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000307 // cbnz x7, LBB0_105 $96(%rip) + WORD $0xb5006f2a // cbnz x10, LBB0_297 $3556(%rip) + WORD $0xd1010318 // sub x24, x24, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff1f // cmp x24, #63 + WORD $0x54fff568 // b.hi LBB0_98 $-340(%rip) + WORD $0x140001de // b LBB0_209 $1912(%rip) +LBB0_103: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c11ef // csel x15, x15, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_104: + WORD $0x8a37014c // bic x12, x10, x23 + WORD $0xaa0c06ed // orr x13, x23, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a00e7 // bic x7, x7, x10 + WORD $0x17ffffd0 // b LBB0_100 $-192(%rip) +LBB0_105: + WORD $0xdac000ec // rbit x12, x7 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x540075c3 // b.lo LBB0_321 $3768(%rip) + WORD $0x8b00018a // add x10, x12, x0 + WORD $0x91000540 // add x0, x10, #1 +LBB0_107: + WORD $0xb7f86980 // tbnz x0, #63, LBB0_291 $3376(%rip) + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb27ff7ea // mov x10, #9223372036854775806 + WORD $0xeb0a011f // cmp x8, x10 + WORD $0x540067c8 // b.hi LBB0_290 $3320(%rip) + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x540065ec // b.gt LBB0_283 $3260(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x5280008a // mov w10, #4 + WORD $0x17fffde9 // b LBB0_3 $-2140(%rip) +LBB0_111: + WORD $0x8b27436a // add x10, x27, w7, uxtw + WORD $0x8b1a0159 // add x25, x10, x26 +LBB0_112: + WORD $0x92800007 // mov x7, #-1 + WORD $0xb40065cf // cbz x15, LBB0_287 $3256(%rip) +LBB0_113: + WORD $0xb40065b7 // cbz x23, LBB0_287 $3252(%rip) + WORD $0xb4006580 // cbz x0, LBB0_287 $3248(%rip) + WORD $0xcb1b0325 // sub x5, x25, x27 + WORD $0xd10004aa // sub x10, x5, #1 + WORD $0xeb0a01ff // cmp x15, x10 + WORD $0x54000160 // b.eq LBB0_121 $44(%rip) + WORD $0xeb0a02ff // cmp x23, x10 + WORD $0x54000120 // b.eq LBB0_121 $36(%rip) + WORD $0xeb0a001f // cmp x0, x10 + WORD $0x540000e0 // b.eq LBB0_121 $28(%rip) + WORD $0xf10006ea // subs x10, x23, #1 + WORD $0x5400018b // b.lt LBB0_125 $48(%rip) + WORD $0xeb0a001f // cmp x0, x10 + WORD $0x54000140 // b.eq LBB0_125 $40(%rip) + WORD $0xaa3703e7 // mvn x7, x23 + WORD $0x14000002 // b LBB0_122 $8(%rip) +LBB0_121: + WORD $0xcb0503e7 // neg x7, x5 +LBB0_122: + WORD $0xb7f86387 // tbnz x7, #63, LBB0_287 $3184(%rip) + WORD $0x8b0800e0 // add x0, x7, x8 +LBB0_124: + WORD $0xf9000020 // str x0, [x1] + WORD $0xaa0803ef // mov x15, x8 + WORD $0xb6ffba08 // tbz x8, #63, LBB0_4 $-2240(%rip) + WORD $0x1400031b // b LBB0_290 $3180(%rip) +LBB0_125: + WORD $0xaa0001ea // orr x10, x15, x0 + WORD $0xb7f8168a // tbnz x10, #63, LBB0_154 $720(%rip) + WORD $0xeb0001ff // cmp x15, x0 + WORD $0x5400164b // b.lt LBB0_154 $712(%rip) + WORD $0xaa2f03e7 // mvn x7, x15 + WORD $0x17fffff5 // b LBB0_122 $-44(%rip) +LBB0_128: + WORD $0xf9400476 // ldr x22, [x3, #8] + WORD $0xeb0002d8 // subs x24, x22, x0 + WORD $0x54006f00 // b.eq LBB0_320 $3552(%rip) + WORD $0xaa0e03fc // mov x28, x14 + WORD $0xf101031f // cmp x24, #64 + WORD $0x540052a3 // b.lo LBB0_266 $2644(%rip) + WORD $0xd2800017 // mov x23, #0 + WORD $0x9280000f // mov x15, #-1 + WORD $0x92800019 // mov x25, #-1 +LBB0_131: + WORD $0x8b00012a // add x10, x9, x0 + WORD $0xad405957 // ldp q23, q22, [x10] + WORD $0xad415155 // ldp q21, q20, [x10, #32] + WORD $0x6e208ef8 // cmeq.16b v24, v23, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030a // fmov w10, s24 + WORD $0x6e208ed8 // cmeq.16b v24, v22, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030c // fmov w12, s24 + WORD $0x6e208eb8 // cmeq.16b v24, v21, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030d // fmov w13, s24 + WORD $0x6e208e98 // cmeq.16b v24, v20, v0 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26030e // fmov w14, s24 + WORD $0x6e238ef8 // cmeq.16b v24, v23, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260311 // fmov w17, s24 + WORD $0x6e238ed8 // cmeq.16b v24, v22, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e260305 // fmov w5, s24 + WORD $0x6e238eb8 // cmeq.16b v24, v21, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031a // fmov w26, s24 + WORD $0x6e238e98 // cmeq.16b v24, v20, v3 + WORD $0x4e211f18 // and.16b v24, v24, v1 + WORD $0x4e020318 // tbl.16b v24, { v24 }, v2 + WORD $0x4e71bb18 // addv.8h h24, v24 + WORD $0x1e26031b // fmov w27, s24 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a0187 // orr x7, x12, x10 + WORD $0xd3607f4a // lsl x10, x26, #32 + WORD $0xb3503f6a // bfi x10, x27, #48, #16 + WORD $0x53103cac // lsl w12, w5, #16 + WORD $0xaa0c014a // orr x10, x10, x12 + WORD $0xaa11014a // orr x10, x10, x17 + WORD $0xb500044a // cbnz x10, LBB0_136 $136(%rip) + WORD $0xb50004f7 // cbnz x23, LBB0_137 $156(%rip) +LBB0_133: + WORD $0x6e373497 // cmhi.16b v23, v4, v23 + WORD $0x4e211ef7 // and.16b v23, v23, v1 + WORD $0x4e0202f7 // tbl.16b v23, { v23 }, v2 + WORD $0x4e71baf7 // addv.8h h23, v23 + WORD $0x1e2602ea // fmov w10, s23 + WORD $0x6e363496 // cmhi.16b v22, v4, v22 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ad // fmov w13, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028e // fmov w14, s20 + WORD $0xd3607dad // lsl x13, x13, #32 + WORD $0xb3503dcd // bfi x13, x14, #48, #16 + WORD $0x53103d8c // lsl w12, w12, #16 + WORD $0xaa0c01ac // orr x12, x13, x12 + WORD $0xaa0a018a // orr x10, x12, x10 + WORD $0xb5000967 // cbnz x7, LBB0_152 $300(%rip) + WORD $0xb5005a2a // cbnz x10, LBB0_297 $2884(%rip) + WORD $0xd1010318 // sub x24, x24, #64 + WORD $0x91010000 // add x0, x0, #64 + WORD $0xf100ff1f // cmp x24, #63 + WORD $0x54fff568 // b.hi LBB0_131 $-340(%rip) + WORD $0x140001ba // b LBB0_241 $1768(%rip) +LBB0_136: + WORD $0xb100073f // cmn x25, #1 + WORD $0xdac0014c // rbit x12, x10 + WORD $0xdac0118c // clz x12, x12 + WORD $0x8b00018c // add x12, x12, x0 + WORD $0x9a8c11ef // csel x15, x15, x12, ne + WORD $0x9a8c1339 // csel x25, x25, x12, ne +LBB0_137: + WORD $0x8a37014c // bic x12, x10, x23 + WORD $0xaa0c06ed // orr x13, x23, x12, lsl #1 + WORD $0x8a2d014a // bic x10, x10, x13 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0c014a // adds x10, x10, x12 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0xd37ff94a // lsl x10, x10, #1 + WORD $0xd200f14a // eor x10, x10, #0x5555555555555555 + WORD $0x8a0d014a // and x10, x10, x13 + WORD $0x8a2a00e7 // bic x7, x7, x10 + WORD $0x17ffffd0 // b LBB0_133 $-192(%rip) +LBB0_138: + WORD $0xf940046a // ldr x10, [x3, #8] + WORD $0xeb00015a // subs x26, x10, x0 + WORD $0x54005860 // b.eq LBB0_302 $2828(%rip) + WORD $0x8b00012f // add x15, x9, x0 + WORD $0x394001ea // ldrb w10, [x15] + WORD $0x7100c15f // cmp w10, #48 + WORD $0x540009c1 // b.ne LBB0_158 $312(%rip) + WORD $0xf100075f // cmp x26, #1 + WORD $0x54000841 // b.ne LBB0_156 $264(%rip) +LBB0_141: + WORD $0x52800039 // mov w25, #1 + WORD $0x14000154 // b LBB0_217 $1360(%rip) +LBB0_142: + WORD $0xf9400048 // ldr x8, [x2] + WORD $0xf13ffd1f // cmp x8, #4095 + WORD $0x5400514c // b.gt LBB0_283 $2600(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900004a // str x10, [x2] + WORD $0x8b080c48 // add x8, x2, x8, lsl #3 + WORD $0x528000aa // mov w10, #5 + WORD $0x17fffd44 // b LBB0_3 $-2800(%rip) +LBB0_144: + WORD $0xf940046a // ldr x10, [x3, #8] + WORD $0xd100114c // sub x12, x10, #4 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x540055a2 // b.hs LBB0_301 $2740(%rip) + WORD $0xb860692a // ldr w10, [x9, x0] + WORD $0x528d8c2c // mov w12, #27745 + WORD $0x72acae6c // movk w12, #25971, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x540055a1 // b.ne LBB0_304 $2740(%rip) + WORD $0x91001500 // add x0, x8, #5 + WORD $0x17fffebd // b LBB0_92 $-1292(%rip) +LBB0_147: + WORD $0xf940046a // ldr x10, [x3, #8] + WORD $0xd1000d4c // sub x12, x10, #3 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x54005442 // b.hs LBB0_301 $2696(%rip) + WORD $0xb940036a // ldr w10, [x27] + WORD $0x528eadcc // mov w12, #30062 + WORD $0x72ad8d8c // movk w12, #27756, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x54000160 // b.eq LBB0_151 $44(%rip) + WORD $0x140002b5 // b LBB0_309 $2772(%rip) +LBB0_149: + WORD $0xf940046a // ldr x10, [x3, #8] + WORD $0xd1000d4c // sub x12, x10, #3 + WORD $0xeb0c011f // cmp x8, x12 + WORD $0x54005302 // b.hs LBB0_301 $2656(%rip) + WORD $0xb940036a // ldr w10, [x27] + WORD $0x528e4e8c // mov w12, #29300 + WORD $0x72acaeac // movk w12, #25973, lsl #16 + WORD $0x6b0c015f // cmp w10, w12 + WORD $0x54005801 // b.ne LBB0_313 $2816(%rip) +LBB0_151: + WORD $0x91001100 // add x0, x8, #4 + WORD $0x17fffea8 // b LBB0_92 $-1376(%rip) +LBB0_152: + WORD $0xdac000ec // rbit x12, x7 + WORD $0xdac0118c // clz x12, x12 + WORD $0xdac0014a // rbit x10, x10 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54005a63 // b.lo LBB0_321 $2892(%rip) + WORD $0x8b00018a // add x10, x12, x0 + WORD $0x91000540 // add x0, x10, #1 + WORD $0xaa1c03ee // mov x14, x28 + WORD $0xb6ffd3c0 // tbz x0, #63, LBB0_92 $-1416(%rip) + WORD $0x1400026f // b LBB0_291 $2492(%rip) +LBB0_154: + WORD $0xd37ffd4a // lsr x10, x10, #63 + WORD $0x5200014a // eor w10, w10, #0x1 + WORD $0xd100040c // sub x12, x0, #1 + WORD $0xeb0c01ff // cmp x15, x12 + WORD $0x1a9f17ec // cset w12, eq + WORD $0x6a0c015f // tst w10, w12 + WORD $0xda8000a7 // csinv x7, x5, x0, eq + WORD $0x17ffff3e // b LBB0_122 $-776(%rip) +LBB0_155: + WORD $0xaa0503f9 // mov x25, x5 + WORD $0x92800007 // mov x7, #-1 + WORD $0xb5ffe54f // cbnz x15, LBB0_113 $-856(%rip) + WORD $0x14000256 // b LBB0_287 $2392(%rip) +LBB0_156: + WORD $0x394005ea // ldrb w10, [x15, #1] + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x54fff788 // b.hi LBB0_141 $-272(%rip) + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0x52800039 // mov w25, #1 + WORD $0xb20903ec // mov x12, #36028797027352576 + WORD $0xf280002c // movk x12, #1 + WORD $0xea0c015f // tst x10, x12 + WORD $0x54002160 // b.eq LBB0_217 $1068(%rip) +LBB0_158: + WORD $0xaa0e03e6 // mov x6, x14 + WORD $0xf100435f // cmp x26, #16 + WORD $0x54003ca3 // b.lo LBB0_270 $1940(%rip) + WORD $0xd280001b // mov x27, #0 + WORD $0x92800018 // mov x24, #-1 + WORD $0x92800017 // mov x23, #-1 + WORD $0x92800016 // mov x22, #-1 + WORD $0xaa1a03f9 // mov x25, x26 +LBB0_160: + WORD $0x3cfb69f4 // ldr q20, [x15, x27] + WORD $0x6e258e95 // cmeq.16b v21, v20, v5 + WORD $0x6e268e96 // cmeq.16b v22, v20, v6 + WORD $0x6e278e97 // cmeq.16b v23, v20, v7 + WORD $0x4e308698 // add.16b v24, v20, v16 + WORD $0x6e383638 // cmhi.16b v24, v17, v24 + WORD $0x4e321e94 // and.16b v20, v20, v18 + WORD $0x6e338e94 // cmeq.16b v20, v20, v19 + WORD $0x4eb61ef6 // orr.16b v22, v23, v22 + WORD $0x4eb51e97 // orr.16b v23, v20, v21 + WORD $0x4eb61ef7 // orr.16b v23, v23, v22 + WORD $0x4eb81ef7 // orr.16b v23, v23, v24 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602aa // fmov w10, s21 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028d // fmov w13, s20 + WORD $0x4e211ed4 // and.16b v20, v22, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e260291 // fmov w17, s20 + WORD $0x4e211ef4 // and.16b v20, v23, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028c // fmov w12, s20 + WORD $0x2a2c03ec // mvn w12, w12 + WORD $0x32103d8c // orr w12, w12, #0xffff0000 + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac01187 // clz w7, w12 + WORD $0x1ac7228c // lsl w12, w20, w7 + WORD $0x0a2c0145 // bic w5, w10, w12 + WORD $0x0a2c01bc // bic w28, w13, w12 + WORD $0x0a2c022e // bic w14, w17, w12 + WORD $0x710040ff // cmp w7, #16 + WORD $0x1a85014c // csel w12, w10, w5, eq + WORD $0x1a9c01aa // csel w10, w13, w28, eq + WORD $0x1a8e0225 // csel w5, w17, w14, eq + WORD $0x5100058d // sub w13, w12, #1 + WORD $0x6a0c01ad // ands w13, w13, w12 + WORD $0x54003181 // b.ne LBB0_262 $1584(%rip) + WORD $0x5100054d // sub w13, w10, #1 + WORD $0x6a0a01ad // ands w13, w13, w10 + WORD $0xaa0603ee // mov x14, x6 + WORD $0x54002a81 // b.ne LBB0_249 $1360(%rip) + WORD $0x510004ad // sub w13, w5, #1 + WORD $0x6a0501ad // ands w13, w13, w5 + WORD $0x54002a21 // b.ne LBB0_249 $1348(%rip) + WORD $0x340000cc // cbz w12, LBB0_166 $24(%rip) + WORD $0x5ac0018c // rbit w12, w12 + WORD $0x5ac0118c // clz w12, w12 + WORD $0xb10006df // cmn x22, #1 + WORD $0x540031a1 // b.ne LBB0_264 $1588(%rip) + WORD $0x8b0c0376 // add x22, x27, x12 +LBB0_166: + WORD $0x340000ca // cbz w10, LBB0_169 $24(%rip) + WORD $0x5ac0014a // rbit w10, w10 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb10006ff // cmn x23, #1 + WORD $0x54002981 // b.ne LBB0_250 $1328(%rip) + WORD $0x8b0a0377 // add x23, x27, x10 +LBB0_169: + WORD $0x340000c5 // cbz w5, LBB0_172 $24(%rip) + WORD $0x5ac000aa // rbit w10, w5 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xb100071f // cmn x24, #1 + WORD $0x540028c1 // b.ne LBB0_250 $1304(%rip) + WORD $0x8b0a0378 // add x24, x27, x10 +LBB0_172: + WORD $0x710040ff // cmp w7, #16 + WORD $0x54000581 // b.ne LBB0_187 $176(%rip) + WORD $0xd1004339 // sub x25, x25, #16 + WORD $0x9100437b // add x27, x27, #16 + WORD $0xf1003f3f // cmp x25, #15 + WORD $0x54fff6e8 // b.hi LBB0_160 $-292(%rip) + WORD $0x8b1b01e7 // add x7, x15, x27 + WORD $0xeb1b035f // cmp x26, x27 + WORD $0xaa0603ee // mov x14, x6 + WORD $0x52800046 // mov w6, #2 + WORD $0x540004c0 // b.eq LBB0_188 $152(%rip) +LBB0_175: + WORD $0x8b1900f1 // add x17, x7, x25 + WORD $0xf9401bea // ldr x10, [sp, #48] + WORD $0x8b07014a // add x10, x10, x7 + WORD $0xcb08015a // sub x26, x10, x8 + WORD $0xaa0703fb // mov x27, x7 + WORD $0x14000008 // b LBB0_179 $32(%rip) +LBB0_176: + WORD $0xb10006df // cmn x22, #1 + WORD $0x54002541 // b.ne LBB0_248 $1192(%rip) + WORD $0xd1000756 // sub x22, x26, #1 +LBB0_178: + WORD $0x9100075a // add x26, x26, #1 + WORD $0xaa1b03e7 // mov x7, x27 + WORD $0xd1000739 // sub x25, x25, #1 + WORD $0xb4001979 // cbz x25, LBB0_229 $812(%rip) +LBB0_179: + WORD $0x38c0176a // ldrsb w10, [x27], #1 + WORD $0x5100c14c // sub w12, w10, #48 + WORD $0x7100299f // cmp w12, #10 + WORD $0x54ffff23 // b.lo LBB0_178 $-28(%rip) + WORD $0x5100ad4c // sub w12, w10, #43 + WORD $0x7100699f // cmp w12, #26 + WORD $0x54000128 // b.hi LBB0_184 $36(%rip) + WORD $0x10fffe4a // adr x10, LBB0_176 $-56(%rip) + WORD $0x386c6a6d // ldrb w13, [x19, x12] + WORD $0x8b0d094a // add x10, x10, x13, lsl #2 + WORD $0xd61f0140 // br x10 +LBB0_182: + WORD $0xb100071f // cmn x24, #1 + WORD $0x54002301 // b.ne LBB0_248 $1120(%rip) + WORD $0xd1000758 // sub x24, x26, #1 + WORD $0x17ffffee // b LBB0_178 $-72(%rip) +LBB0_184: + WORD $0x7101955f // cmp w10, #101 + WORD $0x54000101 // b.ne LBB0_188 $32(%rip) +LBB0_185: + WORD $0xb10006ff // cmn x23, #1 + WORD $0x54002241 // b.ne LBB0_248 $1096(%rip) + WORD $0xd1000757 // sub x23, x26, #1 + WORD $0x17ffffe8 // b LBB0_178 $-96(%rip) +LBB0_187: + WORD $0x8b2741ea // add x10, x15, w7, uxtw + WORD $0x8b1b0147 // add x7, x10, x27 + WORD $0x52800046 // mov w6, #2 +LBB0_188: + WORD $0x92800019 // mov x25, #-1 + WORD $0xb4003eb6 // cbz x22, LBB0_303 $2004(%rip) +LBB0_189: + WORD $0xb4003e98 // cbz x24, LBB0_303 $2000(%rip) + WORD $0xb4003e77 // cbz x23, LBB0_303 $1996(%rip) + WORD $0xcb0f00ef // sub x15, x7, x15 + WORD $0xd10005ea // sub x10, x15, #1 + WORD $0xeb0a02df // cmp x22, x10 + WORD $0x54000160 // b.eq LBB0_197 $44(%rip) + WORD $0xeb0a031f // cmp x24, x10 + WORD $0x54000120 // b.eq LBB0_197 $36(%rip) + WORD $0xeb0a02ff // cmp x23, x10 + WORD $0x540000e0 // b.eq LBB0_197 $28(%rip) + WORD $0xf100070a // subs x10, x24, #1 + WORD $0x540007cb // b.lt LBB0_205 $248(%rip) + WORD $0xeb0a02ff // cmp x23, x10 + WORD $0x54000780 // b.eq LBB0_205 $240(%rip) + WORD $0xaa3803f9 // mvn x25, x24 + WORD $0x1400007c // b LBB0_216 $496(%rip) +LBB0_197: + WORD $0xcb0f03f9 // neg x25, x15 + WORD $0x1400007a // b LBB0_216 $488(%rip) +LBB0_198: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008307 // subs x7, x24, #32 + WORD $0x54000fa3 // b.lo LBB0_220 $500(%rip) +LBB0_199: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602d8 // fmov w24, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e238eb6 // cmeq.16b v22, v21, v3 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c5 // fmov w5, s22 + WORD $0x6e238e96 // cmeq.16b v22, v20, v3 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x33103d58 // bfi w24, w10, #16, #16 + WORD $0x33103d85 // bfi w5, w12, #16, #16 + WORD $0x350028a5 // cbnz w5, LBB0_271 $1300(%rip) + WORD $0xb5002957 // cbnz x23, LBB0_272 $1320(%rip) +LBB0_201: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb4000a78 // cbz x24, LBB0_218 $332(%rip) + WORD $0xdac0030c // rbit x12, x24 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54003f83 // b.lo LBB0_322 $2032(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0x17fffdc4 // b LBB0_91 $-2288(%rip) +LBB0_204: + WORD $0x5ac0018a // rbit w10, w12 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3a03ec // mvn x12, x26 + WORD $0xcb0a0187 // sub x7, x12, x10 + WORD $0x17fffe69 // b LBB0_122 $-1628(%rip) +LBB0_205: + WORD $0xaa1702ca // orr x10, x22, x23 + WORD $0xb7f8074a // tbnz x10, #63, LBB0_215 $232(%rip) + WORD $0xeb1702df // cmp x22, x23 + WORD $0x5400070b // b.lt LBB0_215 $224(%rip) + WORD $0xaa3603f9 // mvn x25, x22 + WORD $0x1400003d // b LBB0_216 $244(%rip) +LBB0_208: + WORD $0xaa3a03ec // mvn x12, x26 + WORD $0xcb2a4187 // sub x7, x12, w10, uxtw + WORD $0x17fffe60 // b LBB0_122 $-1664(%rip) +LBB0_209: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008307 // subs x7, x24, #32 + WORD $0x54000c63 // b.lo LBB0_232 $396(%rip) +LBB0_210: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602d8 // fmov w24, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e238eb6 // cmeq.16b v22, v21, v3 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c5 // fmov w5, s22 + WORD $0x6e238e96 // cmeq.16b v22, v20, v3 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x33103d58 // bfi w24, w10, #16, #16 + WORD $0x33103d85 // bfi w5, w12, #16, #16 + WORD $0x35002325 // cbnz w5, LBB0_273 $1124(%rip) + WORD $0xb50023d7 // cbnz x23, LBB0_274 $1144(%rip) +LBB0_212: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb4000738 // cbz x24, LBB0_230 $228(%rip) + WORD $0xdac0030c // rbit x12, x24 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x540037e3 // b.lo LBB0_323 $1788(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0x17fffe0b // b LBB0_107 $-2004(%rip) +LBB0_215: + WORD $0xd37ffd4a // lsr x10, x10, #63 + WORD $0x5200014a // eor w10, w10, #0x1 + WORD $0xd10006ec // sub x12, x23, #1 + WORD $0xeb0c02df // cmp x22, x12 + WORD $0x1a9f17ec // cset w12, eq + WORD $0x6a0c015f // tst w10, w12 + WORD $0xda9701f9 // csinv x25, x15, x23, eq +LBB0_216: + WORD $0xb7f82d39 // tbnz x25, #63, LBB0_303 $1444(%rip) +LBB0_217: + WORD $0x8b000320 // add x0, x25, x0 + WORD $0x17fffd7b // b LBB0_92 $-2580(%rip) +LBB0_218: + WORD $0x350035ac // cbnz w12, LBB0_322 $1716(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa0703f8 // mov x24, x7 +LBB0_220: + WORD $0xb5002117 // cbnz x23, LBB0_275 $1056(%rip) + WORD $0xb40026f8 // cbz x24, LBB0_285 $1244(%rip) +LBB0_222: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x54000300 // b.eq LBB0_228 $96(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_226 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54003509 // b.ls LBB0_324 $1696(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab180158 // adds x24, x10, x24 + WORD $0x54fffea1 // b.ne LBB0_222 $-44(%rip) + WORD $0x1400012a // b LBB0_285 $1192(%rip) +LBB0_226: + WORD $0xf100071f // cmp x24, #1 + WORD $0x54002500 // b.eq LBB0_285 $1184(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb10006df // cmn x22, #1 + WORD $0x9a8a12d6 // csel x22, x22, x10, ne + WORD $0x52800046 // mov w6, #2 + WORD $0x9a8610cc // csel x12, x6, x6, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab180158 // adds x24, x10, x24 + WORD $0x54fffd01 // b.ne LBB0_222 $-96(%rip) + WORD $0x1400011d // b LBB0_285 $1140(%rip) +LBB0_228: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0x17fffd58 // b LBB0_91 $-2720(%rip) +LBB0_229: + WORD $0xaa1103e7 // mov x7, x17 + WORD $0x92800019 // mov x25, #-1 + WORD $0xb5ffe9d6 // cbnz x22, LBB0_189 $-712(%rip) + WORD $0x14000141 // b LBB0_303 $1284(%rip) +LBB0_230: + WORD $0x3500314c // cbnz w12, LBB0_323 $1576(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa0703f8 // mov x24, x7 +LBB0_232: + WORD $0xb5001d97 // cbnz x23, LBB0_277 $944(%rip) + WORD $0xb4002498 // cbz x24, LBB0_292 $1168(%rip) +LBB0_234: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x54000300 // b.eq LBB0_240 $96(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_238 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54003089 // b.ls LBB0_325 $1552(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab180158 // adds x24, x10, x24 + WORD $0x54fffea1 // b.ne LBB0_234 $-44(%rip) + WORD $0x14000117 // b LBB0_292 $1116(%rip) +LBB0_238: + WORD $0xf100071f // cmp x24, #1 + WORD $0x540022a0 // b.eq LBB0_292 $1108(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb10005ff // cmn x15, #1 + WORD $0x9a8a11ef // csel x15, x15, x10, ne + WORD $0x52800046 // mov w6, #2 + WORD $0x9a8610cc // csel x12, x6, x6, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab180158 // adds x24, x10, x24 + WORD $0x54fffd01 // b.ne LBB0_234 $-96(%rip) + WORD $0x1400010a // b LBB0_292 $1064(%rip) +LBB0_240: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0x17fffdb9 // b LBB0_107 $-2332(%rip) +LBB0_241: + WORD $0x8b000120 // add x0, x9, x0 + WORD $0xf1008307 // subs x7, x24, #32 + WORD $0x54001083 // b.lo LBB0_267 $528(%rip) +LBB0_242: + WORD $0xad405015 // ldp q21, q20, [x0] + WORD $0x6e208eb6 // cmeq.16b v22, v21, v0 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602d8 // fmov w24, s22 + WORD $0x6e208e96 // cmeq.16b v22, v20, v0 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602ca // fmov w10, s22 + WORD $0x6e238eb6 // cmeq.16b v22, v21, v3 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602c5 // fmov w5, s22 + WORD $0x6e238e96 // cmeq.16b v22, v20, v3 + WORD $0x4e211ed6 // and.16b v22, v22, v1 + WORD $0x4e0202d6 // tbl.16b v22, { v22 }, v2 + WORD $0x4e71bad6 // addv.8h h22, v22 + WORD $0x1e2602cc // fmov w12, s22 + WORD $0x33103d58 // bfi w24, w10, #16, #16 + WORD $0x33103d85 // bfi w5, w12, #16, #16 + WORD $0x350017a5 // cbnz w5, LBB0_279 $756(%rip) + WORD $0xb5001857 // cbnz x23, LBB0_280 $776(%rip) + WORD $0xaa1c03ee // mov x14, x28 +LBB0_245: + WORD $0x6e353495 // cmhi.16b v21, v4, v21 + WORD $0x4e211eb5 // and.16b v21, v21, v1 + WORD $0x4e0202b5 // tbl.16b v21, { v21 }, v2 + WORD $0x4e71bab5 // addv.8h h21, v21 + WORD $0x1e2602ac // fmov w12, s21 + WORD $0x6e343494 // cmhi.16b v20, v4, v20 + WORD $0x4e211e94 // and.16b v20, v20, v1 + WORD $0x4e020294 // tbl.16b v20, { v20 }, v2 + WORD $0x4e71ba94 // addv.8h h20, v20 + WORD $0x1e26028a // fmov w10, s20 + WORD $0x33103d4c // bfi w12, w10, #16, #16 + WORD $0xdac0018a // rbit x10, x12 + WORD $0xdac0114a // clz x10, x10 + WORD $0xb40002d8 // cbz x24, LBB0_251 $88(%rip) + WORD $0xdac0030c // rbit x12, x24 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0c015f // cmp x10, x12 + WORD $0x54002743 // b.lo LBB0_323 $1256(%rip) + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b00014a // add x10, x10, x0 + WORD $0x8b0c0140 // add x0, x10, x12 + WORD $0xb6ffa000 // tbz x0, #63, LBB0_92 $-3072(%rip) + WORD $0x140000d1 // b LBB0_291 $836(%rip) +LBB0_248: + WORD $0xcb1a03f9 // neg x25, x26 + WORD $0x17ffff80 // b LBB0_216 $-512(%rip) +LBB0_249: + WORD $0x5ac001aa // rbit w10, w13 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3b03ec // mvn x12, x27 + WORD $0xcb0a0199 // sub x25, x12, x10 + WORD $0x52800046 // mov w6, #2 + WORD $0x17ffff7a // b LBB0_216 $-536(%rip) +LBB0_250: + WORD $0xaa3b03ec // mvn x12, x27 + WORD $0xcb2a4199 // sub x25, x12, w10, uxtw + WORD $0x52800046 // mov w6, #2 + WORD $0x17ffff76 // b LBB0_216 $-552(%rip) +LBB0_251: + WORD $0x3500250c // cbnz w12, LBB0_323 $1184(%rip) + WORD $0x91008000 // add x0, x0, #32 + WORD $0xaa0703f8 // mov x24, x7 + WORD $0xb50008b7 // cbnz x23, LBB0_268 $276(%rip) +LBB0_253: + WORD $0xb4001858 // cbz x24, LBB0_292 $776(%rip) +LBB0_254: + WORD $0x3940000a // ldrb w10, [x0] + WORD $0x7100895f // cmp w10, #34 + WORD $0x540003e0 // b.eq LBB0_261 $124(%rip) + WORD $0x7101715f // cmp w10, #92 + WORD $0x54000120 // b.eq LBB0_258 $36(%rip) + WORD $0x71007d5f // cmp w10, #31 + WORD $0x54002449 // b.ls LBB0_325 $1160(%rip) + WORD $0x9280000a // mov x10, #-1 + WORD $0x5280002c // mov w12, #1 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab180158 // adds x24, x10, x24 + WORD $0x54fffea1 // b.ne LBB0_254 $-44(%rip) + WORD $0x140000b5 // b LBB0_292 $724(%rip) +LBB0_258: + WORD $0xf100071f // cmp x24, #1 + WORD $0x54001660 // b.eq LBB0_292 $716(%rip) + WORD $0xcb09000a // sub x10, x0, x9 + WORD $0xb10005ff // cmn x15, #1 + WORD $0x9a8a11ef // csel x15, x15, x10, ne + WORD $0x52800046 // mov w6, #2 + WORD $0x9a8610cc // csel x12, x6, x6, ne + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a8a114a // csel x10, x10, x10, ne + WORD $0xaa1c03ee // mov x14, x28 + WORD $0x8b0c0000 // add x0, x0, x12 + WORD $0xab180158 // adds x24, x10, x24 + WORD $0x54fffce1 // b.ne LBB0_254 $-100(%rip) + WORD $0x140000a7 // b LBB0_292 $668(%rip) +LBB0_260: + WORD $0xd2800017 // mov x23, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x92800016 // mov x22, #-1 + WORD $0xf1008307 // subs x7, x24, #32 + WORD $0x54ffdb62 // b.hs LBB0_199 $-1172(%rip) + WORD $0x17ffff56 // b LBB0_220 $-680(%rip) +LBB0_261: + WORD $0xf94017ea // ldr x10, [sp, #40] + WORD $0x8b000140 // add x0, x10, x0 + WORD $0xb6ff9940 // tbz x0, #63, LBB0_92 $-3288(%rip) + WORD $0x1400009b // b LBB0_291 $620(%rip) +LBB0_262: + WORD $0x5ac001aa // rbit w10, w13 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3b03ec // mvn x12, x27 + WORD $0xcb0a0199 // sub x25, x12, x10 + WORD $0xaa0603ee // mov x14, x6 + WORD $0x52800046 // mov w6, #2 + WORD $0x17ffff45 // b LBB0_216 $-748(%rip) +LBB0_263: + WORD $0x9280000f // mov x15, #-1 + WORD $0xaa1b03f9 // mov x25, x27 + WORD $0xaa1603f8 // mov x24, x22 + WORD $0x92800000 // mov x0, #-1 + WORD $0x92800017 // mov x23, #-1 + WORD $0x17fffc86 // b LBB0_77 $-3560(%rip) +LBB0_264: + WORD $0xaa3b03ea // mvn x10, x27 + WORD $0xcb2c4159 // sub x25, x10, w12, uxtw + WORD $0x52800046 // mov w6, #2 + WORD $0x17ffff3b // b LBB0_216 $-788(%rip) +LBB0_265: + WORD $0xd2800017 // mov x23, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x9280000f // mov x15, #-1 + WORD $0xf1008307 // subs x7, x24, #32 + WORD $0x54ffe002 // b.hs LBB0_210 $-1024(%rip) + WORD $0x17ffff61 // b LBB0_232 $-636(%rip) +LBB0_266: + WORD $0xd2800017 // mov x23, #0 + WORD $0x8b000120 // add x0, x9, x0 + WORD $0x9280000f // mov x15, #-1 + WORD $0xf1008307 // subs x7, x24, #32 + WORD $0x54ffefc2 // b.hs LBB0_242 $-520(%rip) +LBB0_267: + WORD $0xaa1c03ee // mov x14, x28 + WORD $0xb4fff7b7 // cbz x23, LBB0_253 $-268(%rip) +LBB0_268: + WORD $0xb4000fd8 // cbz x24, LBB0_292 $504(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb10005ff // cmn x15, #1 + WORD $0x9a8f014f // csel x15, x10, x15, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd1000718 // sub x24, x24, #1 + WORD $0xaa1c03ee // mov x14, x28 + WORD $0x52800046 // mov w6, #2 + WORD $0xb5fff698 // cbnz x24, LBB0_254 $-304(%rip) + WORD $0x14000074 // b LBB0_292 $464(%rip) +LBB0_270: + WORD $0x92800016 // mov x22, #-1 + WORD $0xaa0f03e7 // mov x7, x15 + WORD $0xaa1a03f9 // mov x25, x26 + WORD $0x92800017 // mov x23, #-1 + WORD $0x92800018 // mov x24, #-1 + WORD $0xaa0603ee // mov x14, x6 + WORD $0x52800046 // mov w6, #2 + WORD $0x17fffe69 // b LBB0_175 $-1628(%rip) +LBB0_271: + WORD $0xdac000aa // rbit x10, x5 + WORD $0xdac0114a // clz x10, x10 + WORD $0xcb09000c // sub x12, x0, x9 + WORD $0x8b0a018a // add x10, x12, x10 + WORD $0xb10006df // cmn x22, #1 + WORD $0x9a8a12d6 // csel x22, x22, x10, ne +LBB0_272: + WORD $0x0a3700aa // bic w10, w5, w23 + WORD $0x531f794c // lsl w12, w10, #1 + WORD $0x331f7957 // bfi w23, w10, #1, #31 + WORD $0x0a2c00ac // bic w12, w5, w12 + WORD $0x1201f18c // and w12, w12, #0xaaaaaaaa + WORD $0x2b0a018a // adds w10, w12, w10 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a17014a // and w10, w10, w23 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a180158 // and x24, x10, x24 + WORD $0x52800046 // mov w6, #2 + WORD $0x17fffeaa // b LBB0_201 $-1368(%rip) +LBB0_273: + WORD $0xdac000aa // rbit x10, x5 + WORD $0xdac0114a // clz x10, x10 + WORD $0xcb09000c // sub x12, x0, x9 + WORD $0x8b0a018a // add x10, x12, x10 + WORD $0xb10005ff // cmn x15, #1 + WORD $0x9a8a11ef // csel x15, x15, x10, ne +LBB0_274: + WORD $0x0a3700aa // bic w10, w5, w23 + WORD $0x531f794c // lsl w12, w10, #1 + WORD $0x331f7957 // bfi w23, w10, #1, #31 + WORD $0x0a2c00ac // bic w12, w5, w12 + WORD $0x1201f18c // and w12, w12, #0xaaaaaaaa + WORD $0x2b0a018a // adds w10, w12, w10 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a17014a // and w10, w10, w23 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a180158 // and x24, x10, x24 + WORD $0x52800046 // mov w6, #2 + WORD $0x17fffed6 // b LBB0_212 $-1192(%rip) +LBB0_275: + WORD $0xb4000618 // cbz x24, LBB0_285 $192(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb10006df // cmn x22, #1 + WORD $0x9a960156 // csel x22, x10, x22, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd1000718 // sub x24, x24, #1 + WORD $0x52800046 // mov w6, #2 + WORD $0xb5ffde58 // cbnz x24, LBB0_222 $-1080(%rip) + WORD $0x14000027 // b LBB0_285 $156(%rip) +LBB0_277: + WORD $0xb4000738 // cbz x24, LBB0_292 $228(%rip) + WORD $0xf94013ea // ldr x10, [sp, #32] + WORD $0x8b0a000a // add x10, x0, x10 + WORD $0xb10005ff // cmn x15, #1 + WORD $0x9a8f014f // csel x15, x10, x15, eq + WORD $0x91000400 // add x0, x0, #1 + WORD $0xd1000718 // sub x24, x24, #1 + WORD $0x52800046 // mov w6, #2 + WORD $0xb5ffe1d8 // cbnz x24, LBB0_234 $-968(%rip) + WORD $0x14000030 // b LBB0_292 $192(%rip) +LBB0_279: + WORD $0xdac000aa // rbit x10, x5 + WORD $0xdac0114a // clz x10, x10 + WORD $0xcb09000c // sub x12, x0, x9 + WORD $0x8b0a018a // add x10, x12, x10 + WORD $0xb10005ff // cmn x15, #1 + WORD $0x9a8a11ef // csel x15, x15, x10, ne +LBB0_280: + WORD $0x0a3700aa // bic w10, w5, w23 + WORD $0x531f794c // lsl w12, w10, #1 + WORD $0x331f7957 // bfi w23, w10, #1, #31 + WORD $0x0a2c00ac // bic w12, w5, w12 + WORD $0x1201f18c // and w12, w12, #0xaaaaaaaa + WORD $0x2b0a018a // adds w10, w12, w10 + WORD $0x3200f3ec // mov w12, #1431655765 + WORD $0x4a0a058a // eor w10, w12, w10, lsl #1 + WORD $0x0a17014a // and w10, w10, w23 + WORD $0x1a9f37f7 // cset w23, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a180158 // and x24, x10, x24 + WORD $0xaa1c03ee // mov x14, x28 + WORD $0x52800046 // mov w6, #2 + WORD $0x17ffff32 // b LBB0_245 $-824(%rip) +LBB0_281: + WORD $0xf9000028 // str x8, [x1] +LBB0_282: + WORD $0x9280000f // mov x15, #-1 + WORD $0x1400000d // b LBB0_290 $52(%rip) +LBB0_283: + WORD $0x928000cf // mov x15, #-7 + WORD $0x1400000b // b LBB0_290 $44(%rip) +LBB0_284: + WORD $0xb100041f // cmn x0, #1 + WORD $0x540003a1 // b.ne LBB0_296 $116(%rip) +LBB0_285: + WORD $0x92800000 // mov x0, #-1 + WORD $0xaa0f03f6 // mov x22, x15 + WORD $0x1400001a // b LBB0_296 $104(%rip) +LBB0_286: + WORD $0x92800007 // mov x7, #-1 +LBB0_287: + WORD $0xaa2703e9 // mvn x9, x7 + WORD $0x8b090108 // add x8, x8, x9 +LBB0_288: + WORD $0xf9000028 // str x8, [x1] +LBB0_289: + WORD $0x9280002f // mov x15, #-2 +LBB0_290: + WORD $0xaa0f03e0 // mov x0, x15 + WORD $0xa9497bfd // ldp x29, x30, [sp, #144] + WORD $0xa9484ff4 // ldp x20, x19, [sp, #128] + WORD $0xa94757f6 // ldp x22, x21, [sp, #112] + WORD $0xa9465ff8 // ldp x24, x23, [sp, #96] + WORD $0xa94567fa // ldp x26, x25, [sp, #80] + WORD $0xa9446ffc // ldp x28, x27, [sp, #64] + WORD $0x910283ff // add sp, sp, #160 + WORD $0xd65f03c0 // ret +LBB0_291: + WORD $0xb100041f // cmn x0, #1 + WORD $0x54000261 // b.ne LBB0_300 $76(%rip) +LBB0_292: + WORD $0x92800000 // mov x0, #-1 + WORD $0xaa1603ef // mov x15, x22 + WORD $0x14000010 // b LBB0_300 $64(%rip) +LBB0_293: + WORD $0xb10006df // cmn x22, #1 + WORD $0x54000081 // b.ne LBB0_295 $16(%rip) + WORD $0xdac00148 // rbit x8, x10 + WORD $0xdac01108 // clz x8, x8 + WORD $0x8b000116 // add x22, x8, x0 +LBB0_295: + WORD $0x92800020 // mov x0, #-2 +LBB0_296: + WORD $0xf9000036 // str x22, [x1] + WORD $0xaa0003ef // mov x15, x0 + WORD $0x17ffffea // b LBB0_290 $-88(%rip) +LBB0_297: + WORD $0xb10005ff // cmn x15, #1 + WORD $0x54000081 // b.ne LBB0_299 $16(%rip) + WORD $0xdac00148 // rbit x8, x10 + WORD $0xdac01108 // clz x8, x8 + WORD $0x8b00010f // add x15, x8, x0 +LBB0_299: + WORD $0x92800020 // mov x0, #-2 +LBB0_300: + WORD $0xf900002f // str x15, [x1] + WORD $0xaa0003ef // mov x15, x0 + WORD $0x17ffffe1 // b LBB0_290 $-124(%rip) +LBB0_301: + WORD $0xf900002a // str x10, [x1] + WORD $0x17ffffd1 // b LBB0_282 $-188(%rip) +LBB0_302: + WORD $0x92800019 // mov x25, #-1 +LBB0_303: + WORD $0xcb190108 // sub x8, x8, x25 + WORD $0x17ffffda // b LBB0_288 $-152(%rip) +LBB0_304: + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x7101855f // cmp w10, #97 + WORD $0x54fffb01 // b.ne LBB0_289 $-160(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101b15f // cmp w10, #108 + WORD $0x54fffa61 // b.ne LBB0_289 $-180(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101cd5f // cmp w10, #115 + WORD $0x54fff9c1 // b.ne LBB0_289 $-200(%rip) + WORD $0x9100110a // add x10, x8, #4 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101953f // cmp w9, #101 + WORD $0x54fff921 // b.ne LBB0_289 $-220(%rip) + WORD $0x91001508 // add x8, x8, #5 + WORD $0x17ffffc6 // b LBB0_288 $-232(%rip) +LBB0_309: + WORD $0xf9000028 // str x8, [x1] + WORD $0x3940036a // ldrb w10, [x27] + WORD $0x7101b95f // cmp w10, #110 + WORD $0x54fff861 // b.ne LBB0_289 $-244(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101d55f // cmp w10, #117 + WORD $0x54fff7c1 // b.ne LBB0_289 $-264(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101b15f // cmp w10, #108 + WORD $0x54fff721 // b.ne LBB0_289 $-284(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101b13f // cmp w9, #108 + WORD $0x54fff681 // b.ne LBB0_289 $-304(%rip) + WORD $0x14000014 // b LBB0_317 $80(%rip) +LBB0_313: + WORD $0xf9000028 // str x8, [x1] + WORD $0x3940036a // ldrb w10, [x27] + WORD $0x7101d15f // cmp w10, #116 + WORD $0x54fff5e1 // b.ne LBB0_289 $-324(%rip) + WORD $0x9100050a // add x10, x8, #1 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101c95f // cmp w10, #114 + WORD $0x54fff541 // b.ne LBB0_289 $-344(%rip) + WORD $0x9100090a // add x10, x8, #2 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a692a // ldrb w10, [x9, x10] + WORD $0x7101d55f // cmp w10, #117 + WORD $0x54fff4a1 // b.ne LBB0_289 $-364(%rip) + WORD $0x91000d0a // add x10, x8, #3 + WORD $0xf900002a // str x10, [x1] + WORD $0x386a6929 // ldrb w9, [x9, x10] + WORD $0x7101953f // cmp w9, #101 + WORD $0x54fff401 // b.ne LBB0_289 $-384(%rip) +LBB0_317: + WORD $0x91001108 // add x8, x8, #4 + WORD $0x17ffff9d // b LBB0_288 $-396(%rip) +LBB0_318: + WORD $0xaa0003ef // mov x15, x0 + WORD $0x17ffff95 // b LBB0_285 $-428(%rip) +LBB0_319: + WORD $0x8b000156 // add x22, x10, x0 + WORD $0x17ffffae // b LBB0_295 $-328(%rip) +LBB0_320: + WORD $0xaa0003f6 // mov x22, x0 + WORD $0x17ffffa4 // b LBB0_292 $-368(%rip) +LBB0_321: + WORD $0x8b00014f // add x15, x10, x0 + WORD $0x17ffffb3 // b LBB0_299 $-308(%rip) +LBB0_322: + WORD $0xcb090008 // sub x8, x0, x9 + WORD $0x8b0a0116 // add x22, x8, x10 + WORD $0x17ffffa7 // b LBB0_295 $-356(%rip) +LBB0_323: + WORD $0xcb090008 // sub x8, x0, x9 + WORD $0x8b0a010f // add x15, x8, x10 + WORD $0x17ffffad // b LBB0_299 $-332(%rip) +LBB0_324: + WORD $0xcb090016 // sub x22, x0, x9 + WORD $0x17ffffa2 // b LBB0_295 $-376(%rip) +LBB0_325: + WORD $0xcb09000f // sub x15, x0, x9 + WORD $0x17ffffa9 // b LBB0_299 $-348(%rip) + // .p2align 1, 0x00 +LJTI0_0: + WORD $0x00090000 + WORD $0x00860012 + WORD $0x011c008a + // // .word (LBB0_33-LBB0_33)>>2 +// .word (LBB0_36-LBB0_33)>>2 +// .word (LBB0_39-LBB0_33)>>2 +// .word (LBB0_50-LBB0_33)>>2 +// .word (LBB0_52-LBB0_33)>>2 +// .word (LBB0_86-LBB0_33)>>2 + +LJTI0_1: + WORD $0x05530554 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530240 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x02b10553 + WORD $0x05530553 + WORD $0x00f100f1 + WORD $0x00f100f1 + WORD $0x00f100f1 + WORD $0x00f100f1 + WORD $0x00f100f1 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x02bc0553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x055302c4 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x055302cf + WORD $0x05530553 + WORD $0x05530553 + WORD $0x055302d9 + WORD $0x05530553 + WORD $0x05530553 + WORD $0x00000553 + // // .word (LBB0_290-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_128-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_138-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_55-LBB0_1)>>2 +// .word (LBB0_55-LBB0_1)>>2 +// .word (LBB0_55-LBB0_1)>>2 +// .word (LBB0_55-LBB0_1)>>2 +// .word (LBB0_55-LBB0_1)>>2 +// .word (LBB0_55-LBB0_1)>>2 +// .word (LBB0_55-LBB0_1)>>2 +// .word (LBB0_55-LBB0_1)>>2 +// .word (LBB0_55-LBB0_1)>>2 +// .word (LBB0_55-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_142-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_144-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_147-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_149-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_289-LBB0_1)>>2 +// .word (LBB0_1-LBB0_1)>>2 + +LJTI0_2: + WORD $0x00121f12 + WORD $0x1f1f1f1f + WORD $0x1f1f1f1f + WORD $0x1f1f1f1f + WORD $0x1f1f1f1f + WORD $0x1f1f1f1f + WORD $0x00181f1f + // // .byte (LBB0_182-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_182-LBB0_176)>>2 +// .byte (LBB0_176-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_188-LBB0_176)>>2 +// .byte (LBB0_185-LBB0_176)>>2 + +LJTI0_3: + WORD $0x1713c313 + WORD $0xc3c3c3c3 + WORD $0xc3c3c3c3 + WORD $0xc3c3c3c3 + WORD $0xc3c3c3c3 + WORD $0xc3c3c3c3 + WORD $0x0000c3c3 + // // .byte (LBB0_84-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_84-LBB0_79)>>2 +// .byte (LBB0_85-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_112-LBB0_79)>>2 +// .byte (LBB0_79-LBB0_79)>>2 + +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__validate_one(SB), $0-32 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $192, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_validate_one: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + MOVD m+16(FP), R2 + CALL ·__validate_one_arm64_entry__+76(SB) // _validate_one + MOVD R0, ret+24(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/validate_one_subr_arm64.go b/internal/native/neon/validate_one_subr_arm64.go new file mode 100644 index 000000000..79d51081d --- /dev/null +++ b/internal/native/neon/validate_one_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __validate_one_arm64_entry__() uintptr + +var ( + _subr__validate_one uintptr = __validate_one_arm64_entry__() + 64 +) + +const ( + _stack__validate_one = 160 +) + +var ( + _ = _subr__validate_one +) + +const ( + _ = _stack__validate_one +) diff --git a/internal/native/neon/validate_utf8_arm64.go b/internal/native/neon/validate_utf8_arm64.go new file mode 100644 index 000000000..11b409a13 --- /dev/null +++ b/internal/native/neon/validate_utf8_arm64.go @@ -0,0 +1,38 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +import ( + // `unsafe` + + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) { + return __validate_utf8(s, p, m) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) + diff --git a/internal/native/neon/validate_utf8_arm64.s b/internal/native/neon/validate_utf8_arm64.s new file mode 100644 index 000000000..fb815965b --- /dev/null +++ b/internal/native/neon/validate_utf8_arm64.s @@ -0,0 +1,222 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__validate_utf8_arm64_entry__(SB), NOSPLIT, $48 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910103ff // add sp, sp, #64 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_validate_utf8: + MOVD.W R30, -64(RSP) // WORD $0xf81c0ffe // str x30, [sp, #-64]! + WORD $0xa9034ff4 // stp x20, x19, [sp, #48] + WORD $0xa9402408 // ldp x8, x9, [x0] + WORD $0xf940002c // ldr x12, [x1] + WORD $0x8b09010a // add x10, x8, x9 + WORD $0xd1000d4b // sub x11, x10, #3 + WORD $0x8b0c0109 // add x9, x8, x12 + WORD $0xeb0b013f // cmp x9, x11 + WORD $0x54000722 // b.hs LBB0_15 $228(%rip) + WORD $0x52981e0c // mov w12, #49392 + WORD $0x72a0180c // movk w12, #192, lsl #16 + WORD $0x52901c0d // mov w13, #32992 + WORD $0x72a0100d // movk w13, #128, lsl #16 + WORD $0x528401ee // mov w14, #8207 + WORD $0x528401af // mov w15, #8205 + WORD $0x52981c10 // mov w16, #49376 + WORD $0x52901811 // mov w17, #32960 + WORD $0x52981f00 // mov w0, #49400 + WORD $0x72b81800 // movk w0, #49344, lsl #16 + WORD $0x528600e3 // mov w3, #12295 + WORD $0x52901e04 // mov w4, #33008 + WORD $0x72b01004 // movk w4, #32896, lsl #16 + WORD $0x52860065 // mov w5, #12291 + WORD $0x14000005 // b LBB0_4 $20(%rip) +LBB0_2: + WORD $0x52800027 // mov w7, #1 +LBB0_3: + WORD $0x8b070129 // add x9, x9, x7 + WORD $0xeb0b013f // cmp x9, x11 + WORD $0x540004c2 // b.hs LBB0_15 $152(%rip) +LBB0_4: + WORD $0x39c00126 // ldrsb w6, [x9] + WORD $0x36ffff66 // tbz w6, #31, LBB0_2 $-20(%rip) + WORD $0xb9400126 // ldr w6, [x9] + WORD $0x0a0c00c7 // and w7, w6, w12 + WORD $0x6b0d00ff // cmp w7, w13 + WORD $0x0a0e00c7 // and w7, w6, w14 + WORD $0x7a4f00e4 // ccmp w7, w15, #4, eq + WORD $0x7a4018e4 // ccmp w7, #0, #4, ne + WORD $0x54000361 // b.ne LBB0_14 $108(%rip) + WORD $0x0a1000c7 // and w7, w6, w16 + WORD $0x121f0cd3 // and w19, w6, #0x1e + WORD $0x6b1100ff // cmp w7, w17 + WORD $0x7a400a64 // ccmp w19, #0, #4, eq + WORD $0x54000281 // b.ne LBB0_13 $80(%rip) + WORD $0x0a0000c7 // and w7, w6, w0 + WORD $0x6b0400ff // cmp w7, w4 + WORD $0x540000e1 // b.ne LBB0_11 $28(%rip) + WORD $0x0a0300c7 // and w7, w6, w3 + WORD $0x340000a7 // cbz w7, LBB0_11 $20(%rip) + WORD $0x52800087 // mov w7, #4 + WORD $0x3617fd26 // tbz w6, #2, LBB0_3 $-92(%rip) + WORD $0x0a0500c6 // and w6, w6, w5 + WORD $0x34fffce6 // cbz w6, LBB0_3 $-100(%rip) +LBB0_11: + WORD $0xcb080126 // sub x6, x9, x8 + WORD $0xf9400047 // ldr x7, [x2] + WORD $0xf14004ff // cmp x7, #1, lsl #12 + WORD $0x54000d22 // b.hs LBB0_34 $420(%rip) + WORD $0x93407cc6 // sxtw x6, w6 + WORD $0x910004f3 // add x19, x7, #1 + WORD $0xf9000053 // str x19, [x2] + WORD $0x8b070c47 // add x7, x2, x7, lsl #3 + WORD $0xf90004e6 // str x6, [x7, #8] + WORD $0x17ffffdc // b LBB0_2 $-144(%rip) +LBB0_13: + WORD $0x52800047 // mov w7, #2 + WORD $0x17ffffdb // b LBB0_3 $-148(%rip) +LBB0_14: + WORD $0x52800067 // mov w7, #3 + WORD $0x17ffffd9 // b LBB0_3 $-156(%rip) +LBB0_15: + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x54000a42 // b.hs LBB0_32 $328(%rip) + WORD $0x52981e0b // mov w11, #49392 + WORD $0x72a0180b // movk w11, #192, lsl #16 + WORD $0x52901c0c // mov w12, #32992 + WORD $0x72a0100c // movk w12, #128, lsl #16 + WORD $0x528401ed // mov w13, #8207 + WORD $0x528401ae // mov w14, #8205 + WORD $0x52981c0f // mov w15, #49376 + WORD $0x52901810 // mov w16, #32960 + WORD $0x14000004 // b LBB0_18 $16(%rip) +LBB0_17: + WORD $0x91000529 // add x9, x9, #1 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x540008c2 // b.hs LBB0_32 $280(%rip) +LBB0_18: + WORD $0x39c00131 // ldrsb w17, [x9] + WORD $0x36ffff91 // tbz w17, #31, LBB0_17 $-16(%rip) + WORD $0x3900b3ff // strb wzr, [sp, #44] + WORD $0x3900abff // strb wzr, [sp, #42] + WORD $0xcb090145 // sub x5, x10, x9 + WORD $0xf10008a6 // subs x6, x5, #2 + WORD $0x54000263 // b.lo LBB0_22 $76(%rip) + WORD $0x39400131 // ldrb w17, [x9] + WORD $0x39400520 // ldrb w0, [x9, #1] + WORD $0x3900b3f1 // strb w17, [sp, #44] + WORD $0x91000924 // add x4, x9, #2 + WORD $0x9100abe3 // add x3, sp, #42 + WORD $0xaa0603e5 // mov x5, x6 + WORD $0xb4000225 // cbz x5, LBB0_23 $68(%rip) +LBB0_21: + WORD $0x39400091 // ldrb w17, [x4] + WORD $0x39000071 // strb w17, [x3] + WORD $0x3940b3f1 // ldrb w17, [sp, #44] + WORD $0x3940abe3 // ldrb w3, [sp, #42] + WORD $0x53185c00 // lsl w0, w0, #8 + WORD $0x33101c60 // bfi w0, w3, #16, #8 + WORD $0x2a110000 // orr w0, w0, w17 + WORD $0x0a0b0003 // and w3, w0, w11 + WORD $0x6b0c007f // cmp w3, w12 + WORD $0x540001c0 // b.eq LBB0_24 $56(%rip) + WORD $0x14000011 // b LBB0_26 $68(%rip) +LBB0_22: + WORD $0x52800011 // mov w17, #0 + WORD $0x52800000 // mov w0, #0 + WORD $0x9100b3e3 // add x3, sp, #44 + WORD $0xaa0903e4 // mov x4, x9 + WORD $0xb5fffe25 // cbnz x5, LBB0_21 $-60(%rip) +LBB0_23: + WORD $0x52800003 // mov w3, #0 + WORD $0x53185c00 // lsl w0, w0, #8 + WORD $0x33101c60 // bfi w0, w3, #16, #8 + WORD $0x2a110000 // orr w0, w0, w17 + WORD $0x0a0b0003 // and w3, w0, w11 + WORD $0x6b0c007f // cmp w3, w12 + WORD $0x540000a1 // b.ne LBB0_26 $20(%rip) +LBB0_24: + WORD $0x0a0d0003 // and w3, w0, w13 + WORD $0x6b0e007f // cmp w3, w14 + WORD $0x54000040 // b.eq LBB0_26 $8(%rip) + WORD $0x35000323 // cbnz w3, LBB0_31 $100(%rip) +LBB0_26: + WORD $0x721f0e3f // tst w17, #0x1e + WORD $0x54000120 // b.eq LBB0_29 $36(%rip) + WORD $0x0a0f0011 // and w17, w0, w15 + WORD $0x6b10023f // cmp w17, w16 + WORD $0x540000c1 // b.ne LBB0_29 $24(%rip) + WORD $0x52800051 // mov w17, #2 + WORD $0x8b110129 // add x9, x9, x17 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x54fff9e3 // b.lo LBB0_18 $-196(%rip) + WORD $0x14000013 // b LBB0_32 $76(%rip) +LBB0_29: + WORD $0xcb080131 // sub x17, x9, x8 + WORD $0xf9400040 // ldr x0, [x2] + WORD $0xf140041f // cmp x0, #1, lsl #12 + WORD $0x540002a2 // b.hs LBB0_33 $84(%rip) + WORD $0x93407e31 // sxtw x17, w17 + WORD $0x91000403 // add x3, x0, #1 + WORD $0xf9000043 // str x3, [x2] + WORD $0x8b000c40 // add x0, x2, x0, lsl #3 + WORD $0xf9000411 // str x17, [x0, #8] + WORD $0x52800031 // mov w17, #1 + WORD $0x8b110129 // add x9, x9, x17 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x54fff823 // b.lo LBB0_18 $-252(%rip) + WORD $0x14000005 // b LBB0_32 $20(%rip) +LBB0_31: + WORD $0x52800071 // mov w17, #3 + WORD $0x8b110129 // add x9, x9, x17 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x54fff783 // b.lo LBB0_18 $-272(%rip) +LBB0_32: + WORD $0xd2800000 // mov x0, #0 + WORD $0xcb080128 // sub x8, x9, x8 + WORD $0xf9000028 // str x8, [x1] + WORD $0xa9434ff4 // ldp x20, x19, [sp, #48] + WORD $0x910103ff // add sp, sp, #64 + WORD $0xd65f03c0 // ret +LBB0_33: + WORD $0xf9000031 // str x17, [x1] + WORD $0x92800000 // mov x0, #-1 + WORD $0xa9434ff4 // ldp x20, x19, [sp, #48] + WORD $0x910103ff // add sp, sp, #64 + WORD $0xd65f03c0 // ret +LBB0_34: + WORD $0xf9000026 // str x6, [x1] + WORD $0x92800000 // mov x0, #-1 + WORD $0xa9434ff4 // ldp x20, x19, [sp, #48] + WORD $0x910103ff // add sp, sp, #64 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__validate_utf8(SB), $0-32 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $96, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_validate_utf8: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + MOVD m+16(FP), R2 + CALL ·__validate_utf8_arm64_entry__+24(SB) // _validate_utf8 + MOVD R0, ret+24(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/validate_utf8_fast_arm64.go b/internal/native/neon/validate_utf8_fast_arm64.go new file mode 100644 index 000000000..dadcad5d3 --- /dev/null +++ b/internal/native/neon/validate_utf8_fast_arm64.go @@ -0,0 +1,31 @@ +// Code generated by Makefile, DO NOT EDIT. + +// Code generated by Makefile, DO NOT EDIT. + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package neon + +//go:nosplit +func validate_utf8_fast(s *string) (ret int) { + return __validate_utf8_fast(s) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __validate_utf8_fast(s *string) (ret int) diff --git a/internal/native/neon/validate_utf8_fast_arm64.s b/internal/native/neon/validate_utf8_fast_arm64.s new file mode 100644 index 000000000..e2776d9b5 --- /dev/null +++ b/internal/native/neon/validate_utf8_fast_arm64.s @@ -0,0 +1,183 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__validate_utf8_fast_arm64_entry__(SB), NOSPLIT, $32 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_validate_utf8_fast: + MOVD.W R30, -48(RSP) // WORD $0xf81d0ffe // str x30, [sp, #-48]! + WORD $0xa9402408 // ldp x8, x9, [x0] + WORD $0x8b090109 // add x9, x8, x9 + WORD $0xd1000d2b // sub x11, x9, #3 + WORD $0xeb08017f // cmp x11, x8 + WORD $0x54000629 // b.ls LBB0_13 $196(%rip) + WORD $0x52981e0c // mov w12, #49392 + WORD $0x72a0180c // movk w12, #192, lsl #16 + WORD $0x52901c0d // mov w13, #32992 + WORD $0x72a0100d // movk w13, #128, lsl #16 + WORD $0x528401ee // mov w14, #8207 + WORD $0x528401af // mov w15, #8205 + WORD $0x52981c10 // mov w16, #49376 + WORD $0x52901811 // mov w17, #32960 + WORD $0x52981f00 // mov w0, #49400 + WORD $0x72b81800 // movk w0, #49344, lsl #16 + WORD $0x528600e1 // mov w1, #12295 + WORD $0x52901e02 // mov w2, #33008 + WORD $0x72b01002 // movk w2, #32896, lsl #16 + WORD $0x52860063 // mov w3, #12291 + WORD $0xaa0803ea // mov x10, x8 + WORD $0x14000005 // b LBB0_4 $20(%rip) +LBB0_2: + WORD $0x52800025 // mov w5, #1 +LBB0_3: + WORD $0x8b05014a // add x10, x10, x5 + WORD $0xeb0b015f // cmp x10, x11 + WORD $0x540003c2 // b.hs LBB0_14 $120(%rip) +LBB0_4: + WORD $0x39c00144 // ldrsb w4, [x10] + WORD $0x36ffff64 // tbz w4, #31, LBB0_2 $-20(%rip) + WORD $0xb9400144 // ldr w4, [x10] + WORD $0x0a0c0085 // and w5, w4, w12 + WORD $0x6b0d00bf // cmp w5, w13 + WORD $0x0a0e0085 // and w5, w4, w14 + WORD $0x7a4f00a4 // ccmp w5, w15, #4, eq + WORD $0x7a4018a4 // ccmp w5, #0, #4, ne + WORD $0x54000241 // b.ne LBB0_12 $72(%rip) + WORD $0x0a100085 // and w5, w4, w16 + WORD $0x121f0c86 // and w6, w4, #0x1e + WORD $0x6b1100bf // cmp w5, w17 + WORD $0x7a4008c4 // ccmp w6, #0, #4, eq + WORD $0x54000161 // b.ne LBB0_11 $44(%rip) + WORD $0x0a000085 // and w5, w4, w0 + WORD $0x6b0200bf // cmp w5, w2 + WORD $0x54000a41 // b.ne LBB0_31 $328(%rip) + WORD $0x0a010085 // and w5, w4, w1 + WORD $0x34000a05 // cbz w5, LBB0_31 $320(%rip) + WORD $0x52800085 // mov w5, #4 + WORD $0x3617fd24 // tbz w4, #2, LBB0_3 $-92(%rip) + WORD $0x0a030084 // and w4, w4, w3 + WORD $0x34fffce4 // cbz w4, LBB0_3 $-100(%rip) + WORD $0x1400004b // b LBB0_31 $300(%rip) +LBB0_11: + WORD $0x52800045 // mov w5, #2 + WORD $0x17ffffe4 // b LBB0_3 $-112(%rip) +LBB0_12: + WORD $0x52800065 // mov w5, #3 + WORD $0x17ffffe2 // b LBB0_3 $-120(%rip) +LBB0_13: + WORD $0xaa0803ea // mov x10, x8 +LBB0_14: + WORD $0xeb09015f // cmp x10, x9 + WORD $0x54000822 // b.hs LBB0_30 $260(%rip) + WORD $0x52981e0b // mov w11, #49392 + WORD $0x72a0180b // movk w11, #192, lsl #16 + WORD $0x52901c0c // mov w12, #32992 + WORD $0x72a0100c // movk w12, #128, lsl #16 + WORD $0x528401ed // mov w13, #8207 + WORD $0x528401ae // mov w14, #8205 + WORD $0x52981c0f // mov w15, #49376 + WORD $0x52901810 // mov w16, #32960 + WORD $0x14000004 // b LBB0_18 $16(%rip) +LBB0_16: + WORD $0x9100054a // add x10, x10, #1 +LBB0_17: + WORD $0xeb09015f // cmp x10, x9 + WORD $0x540006a2 // b.hs LBB0_30 $212(%rip) +LBB0_18: + WORD $0x39c00151 // ldrsb w17, [x10] + WORD $0x36ffff91 // tbz w17, #31, LBB0_16 $-16(%rip) + WORD $0x3900b3ff // strb wzr, [sp, #44] + WORD $0x3900abff // strb wzr, [sp, #42] + WORD $0xcb0a0123 // sub x3, x9, x10 + WORD $0xf1000864 // subs x4, x3, #2 + WORD $0x54000263 // b.lo LBB0_22 $76(%rip) + WORD $0x39400151 // ldrb w17, [x10] + WORD $0x39400540 // ldrb w0, [x10, #1] + WORD $0x3900b3f1 // strb w17, [sp, #44] + WORD $0x91000942 // add x2, x10, #2 + WORD $0x9100abe1 // add x1, sp, #42 + WORD $0xaa0403e3 // mov x3, x4 + WORD $0xb4000223 // cbz x3, LBB0_23 $68(%rip) +LBB0_21: + WORD $0x39400051 // ldrb w17, [x2] + WORD $0x39000031 // strb w17, [x1] + WORD $0x3940b3f1 // ldrb w17, [sp, #44] + WORD $0x3940abe1 // ldrb w1, [sp, #42] + WORD $0x53185c00 // lsl w0, w0, #8 + WORD $0x33101c20 // bfi w0, w1, #16, #8 + WORD $0x2a110000 // orr w0, w0, w17 + WORD $0x0a0b0001 // and w1, w0, w11 + WORD $0x6b0c003f // cmp w1, w12 + WORD $0x540001c0 // b.eq LBB0_24 $56(%rip) + WORD $0x14000011 // b LBB0_26 $68(%rip) +LBB0_22: + WORD $0x52800011 // mov w17, #0 + WORD $0x52800000 // mov w0, #0 + WORD $0x9100b3e1 // add x1, sp, #44 + WORD $0xaa0a03e2 // mov x2, x10 + WORD $0xb5fffe23 // cbnz x3, LBB0_21 $-60(%rip) +LBB0_23: + WORD $0x52800001 // mov w1, #0 + WORD $0x53185c00 // lsl w0, w0, #8 + WORD $0x33101c20 // bfi w0, w1, #16, #8 + WORD $0x2a110000 // orr w0, w0, w17 + WORD $0x0a0b0001 // and w1, w0, w11 + WORD $0x6b0c003f // cmp w1, w12 + WORD $0x540000a1 // b.ne LBB0_26 $20(%rip) +LBB0_24: + WORD $0x0a0d0001 // and w1, w0, w13 + WORD $0x6b0e003f // cmp w1, w14 + WORD $0x54000040 // b.eq LBB0_26 $8(%rip) + WORD $0x35000121 // cbnz w1, LBB0_29 $36(%rip) +LBB0_26: + WORD $0x721f0e3f // tst w17, #0x1e + WORD $0x540001a0 // b.eq LBB0_31 $52(%rip) + WORD $0x0a0f0011 // and w17, w0, w15 + WORD $0x6b10023f // cmp w17, w16 + WORD $0x54000141 // b.ne LBB0_31 $40(%rip) + WORD $0x52800051 // mov w17, #2 + WORD $0x8b11014a // add x10, x10, x17 + WORD $0x17ffffce // b LBB0_17 $-200(%rip) +LBB0_29: + WORD $0x52800071 // mov w17, #3 + WORD $0x8b11014a // add x10, x10, x17 + WORD $0x17ffffcb // b LBB0_17 $-212(%rip) +LBB0_30: + WORD $0xd2800000 // mov x0, #0 + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_31: + WORD $0xaa2a03e9 // mvn x9, x10 + WORD $0x8b080120 // add x0, x9, x8 + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__validate_utf8_fast(SB), $0-16 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $80, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_validate_utf8_fast: + MOVD s+0(FP), R0 + CALL ·__validate_utf8_fast_arm64_entry__+24(SB) // _validate_utf8_fast + MOVD R0, ret+8(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/validate_utf8_fast_subr_arm64.go b/internal/native/neon/validate_utf8_fast_subr_arm64.go new file mode 100644 index 000000000..65020376d --- /dev/null +++ b/internal/native/neon/validate_utf8_fast_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __validate_utf8_fast_arm64_entry__() uintptr + +var ( + _subr__validate_utf8_fast uintptr = __validate_utf8_fast_arm64_entry__() + 12 +) + +const ( + _stack__validate_utf8_fast = 48 +) + +var ( + _ = _subr__validate_utf8_fast +) + +const ( + _ = _stack__validate_utf8_fast +) diff --git a/internal/native/neon/validate_utf8_subr_arm64.go b/internal/native/neon/validate_utf8_subr_arm64.go new file mode 100644 index 000000000..3dddb8411 --- /dev/null +++ b/internal/native/neon/validate_utf8_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __validate_utf8_arm64_entry__() uintptr + +var ( + _subr__validate_utf8 uintptr = __validate_utf8_arm64_entry__() + 12 +) + +const ( + _stack__validate_utf8 = 64 +) + +var ( + _ = _subr__validate_utf8 +) + +const ( + _ = _stack__validate_utf8 +) diff --git a/internal/native/neon/value_arm64.go b/internal/native/neon/value_arm64.go new file mode 100644 index 000000000..7add30d91 --- /dev/null +++ b/internal/native/neon/value_arm64.go @@ -0,0 +1,34 @@ + +/* + * 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 neon + +import ( + `unsafe` + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int) { + return __value(s, n, p, v, flags) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int) + diff --git a/internal/native/neon/value_arm64.s b/internal/native/neon/value_arm64.s new file mode 100644 index 000000000..278819f70 --- /dev/null +++ b/internal/native/neon/value_arm64.s @@ -0,0 +1,6222 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__value_arm64_entry__(SB), NOSPLIT, $80 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_1: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_value: + MOVD.W R30, -96(RSP) // WORD $0xf81a0ffe // str x30, [sp, #-96]! + WORD $0xa90267fa // stp x26, x25, [sp, #32] + WORD $0xa9035ff8 // stp x24, x23, [sp, #48] + WORD $0xa90457f6 // stp x22, x21, [sp, #64] + WORD $0xa9054ff4 // stp x20, x19, [sp, #80] + WORD $0xaa0003e8 // mov x8, x0 + WORD $0xeb01005f // cmp x2, x1 + WORD $0x54000182 // b.hs LBB0_5 $48(%rip) + WORD $0x38626909 // ldrb w9, [x8, x2] + WORD $0x7100353f // cmp w9, #13 + WORD $0x54000120 // b.eq LBB0_5 $36(%rip) + WORD $0x7100813f // cmp w9, #32 + WORD $0x540000e0 // b.eq LBB0_5 $28(%rip) + WORD $0x51002d2a // sub w10, w9, #11 + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x7103f95f // cmp w10, #254 + WORD $0x54000062 // b.hs LBB0_5 $12(%rip) + WORD $0xaa0203ee // mov x14, x2 + WORD $0x1400003f // b LBB0_27 $252(%rip) +LBB0_5: + WORD $0x9100044e // add x14, x2, #1 + WORD $0xeb0101df // cmp x14, x1 + WORD $0x54000142 // b.hs LBB0_9 $40(%rip) + WORD $0x386e6909 // ldrb w9, [x8, x14] + WORD $0x7100353f // cmp w9, #13 + WORD $0x540000e0 // b.eq LBB0_9 $28(%rip) + WORD $0x7100813f // cmp w9, #32 + WORD $0x540000a0 // b.eq LBB0_9 $20(%rip) + WORD $0x51002d2a // sub w10, w9, #11 + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x7103f95f // cmp w10, #254 + WORD $0x54000663 // b.lo LBB0_27 $204(%rip) +LBB0_9: + WORD $0x9100084e // add x14, x2, #2 + WORD $0xeb0101df // cmp x14, x1 + WORD $0x54000142 // b.hs LBB0_13 $40(%rip) + WORD $0x386e6909 // ldrb w9, [x8, x14] + WORD $0x7100353f // cmp w9, #13 + WORD $0x540000e0 // b.eq LBB0_13 $28(%rip) + WORD $0x7100813f // cmp w9, #32 + WORD $0x540000a0 // b.eq LBB0_13 $20(%rip) + WORD $0x51002d2a // sub w10, w9, #11 + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x7103f95f // cmp w10, #254 + WORD $0x540004e3 // b.lo LBB0_27 $156(%rip) +LBB0_13: + WORD $0x91000c4e // add x14, x2, #3 + WORD $0xeb0101df // cmp x14, x1 + WORD $0x54000142 // b.hs LBB0_17 $40(%rip) + WORD $0x386e6909 // ldrb w9, [x8, x14] + WORD $0x7100353f // cmp w9, #13 + WORD $0x540000e0 // b.eq LBB0_17 $28(%rip) + WORD $0x7100813f // cmp w9, #32 + WORD $0x540000a0 // b.eq LBB0_17 $20(%rip) + WORD $0x51002d2a // sub w10, w9, #11 + WORD $0x12001d4a // and w10, w10, #0xff + WORD $0x7103f95f // cmp w10, #254 + WORD $0x54000363 // b.lo LBB0_27 $108(%rip) +LBB0_17: + WORD $0x9100104e // add x14, x2, #4 + WORD $0xeb0101df // cmp x14, x1 + WORD $0x54000222 // b.hs LBB0_22 $68(%rip) + WORD $0xeb0e003f // cmp x1, x14 + WORD $0x54000220 // b.eq LBB0_23 $68(%rip) + WORD $0x8b010109 // add x9, x8, x1 + WORD $0x5280002a // mov w10, #1 + WORD $0xd284c00b // mov x11, #9728 + WORD $0xf2c0002b // movk x11, #1, lsl #32 +LBB0_20: + WORD $0x38ee690c // ldrsb w12, [x8, x14] + WORD $0x7100819f // cmp w12, #32 + WORD $0x9acc214c // lsl x12, x10, x12 + WORD $0x8a0b018c // and x12, x12, x11 + WORD $0xfa409984 // ccmp x12, #0, #4, ls + WORD $0x54000120 // b.eq LBB0_25 $36(%rip) + WORD $0x910005ce // add x14, x14, #1 + WORD $0xeb0e003f // cmp x1, x14 + WORD $0x54ffff01 // b.ne LBB0_20 $-32(%rip) + WORD $0x14000004 // b LBB0_24 $16(%rip) +LBB0_22: + WORD $0xaa0e03e2 // mov x2, x14 + WORD $0x14000020 // b LBB0_34 $128(%rip) +LBB0_23: + WORD $0x8b0e0109 // add x9, x8, x14 +LBB0_24: + WORD $0xcb08012e // sub x14, x9, x8 +LBB0_25: + WORD $0xeb0101df // cmp x14, x1 + WORD $0x54000382 // b.hs LBB0_34 $112(%rip) + WORD $0x386e6909 // ldrb w9, [x8, x14] +LBB0_27: + WORD $0x13001d2a // sxtb w10, w9 + WORD $0x7101f55f // cmp w10, #125 + WORD $0x54002428 // b.hi LBB0_100 $1156(%rip) + WORD $0x910005c2 // add x2, x14, #1 + WORD $0x8b0e010f // add x15, x8, x14 +Lloh0: + WORD $0x10012d4b // adr x11, LJTI0_0 $9640(%rip) +Lloh1: + WORD $0x9100016b // add x11, x11, LJTI0_0@PAGEOFF $0(%rip) + WORD $0x1000008c // adr x12, LBB0_29 $16(%rip) + WORD $0x786a796d // ldrh w13, [x11, x10, lsl #1] + WORD $0x8b0d098c // add x12, x12, x13, lsl #2 + WORD $0xd61f0180 // br x12 +LBB0_29: + WORD $0x37080304 // tbnz w4, #1, LBB0_37 $96(%rip) + WORD $0xa9422869 // ldp x9, x10, [x3, #32] + WORD $0x5280012b // mov w11, #9 + WORD $0xa9007c6b // stp x11, xzr, [x3] + WORD $0xa901387f // stp xzr, x14, [x3, #16] + WORD $0xeb0101df // cmp x14, x1 + WORD $0x54005a62 // b.hs LBB0_191 $2892(%rip) + WORD $0x394001eb // ldrb w11, [x15] + WORD $0x7100b57f // cmp w11, #45 + WORD $0x540003e1 // b.ne LBB0_42 $124(%rip) + WORD $0xeb01005f // cmp x2, x1 + WORD $0x540059c2 // b.hs LBB0_191 $2872(%rip) + WORD $0x38626910 // ldrb w16, [x8, x2] + WORD $0x1280000d // mov w13, #-1 + WORD $0x1400001d // b LBB0_43 $116(%rip) +LBB0_34: + WORD $0x52800028 // mov w8, #1 +LBB0_35: + WORD $0xf9000068 // str x8, [x3] + WORD $0xaa0203e0 // mov x0, x2 +LBB0_36: + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret +LBB0_37: + WORD $0x7100b53f // cmp w9, #45 + WORD $0x1a9f17f0 // cset w16, eq + WORD $0x9a8f15e9 // cinc x9, x15, eq + WORD $0xcb0e002a // sub x10, x1, x14 + WORD $0xeb10014f // subs x15, x10, x16 + WORD $0x5400f4a0 // b.eq LBB0_509 $7828(%rip) + WORD $0x3940012a // ldrb w10, [x9] + WORD $0x5100e94b // sub w11, w10, #58 + WORD $0x3100297f // cmn w11, #10 + WORD $0x54004bc3 // b.lo LBB0_160 $2424(%rip) + WORD $0x7100c15f // cmp w10, #48 + WORD $0x54000301 // b.ne LBB0_47 $96(%rip) + WORD $0xf10005ff // cmp x15, #1 + WORD $0x54000161 // b.ne LBB0_45 $44(%rip) + WORD $0x52800031 // mov w17, #1 + WORD $0x140002c6 // b LBB0_198 $2840(%rip) +LBB0_42: + WORD $0x5280002d // mov w13, #1 + WORD $0xaa0b03f0 // mov x16, x11 + WORD $0xaa0e03e2 // mov x2, x14 +LBB0_43: + WORD $0x5100ea0c // sub w12, w16, #58 + WORD $0x31002d9f // cmn w12, #11 + WORD $0x54001508 // b.hi LBB0_83 $672(%rip) +LBB0_44: + WORD $0x92800028 // mov x8, #-2 + WORD $0x17ffffe1 // b LBB0_35 $-124(%rip) +LBB0_45: + WORD $0x3940052a // ldrb w10, [x9, #1] + WORD $0x52800031 // mov w17, #1 + WORD $0x5100b94a // sub w10, w10, #46 + WORD $0x7100dd5f // cmp w10, #55 + WORD $0x54005728 // b.hi LBB0_198 $2788(%rip) + WORD $0x5280002b // mov w11, #1 + WORD $0x9aca216a // lsl x10, x11, x10 + WORD $0xb20903eb // mov x11, #36028797027352576 + WORD $0xf280002b // movk x11, #1 + WORD $0xea0b015f // tst x10, x11 + WORD $0x54005660 // b.eq LBB0_198 $2764(%rip) +LBB0_47: + WORD $0xf10041ff // cmp x15, #16 + WORD $0x5400f623 // b.lo LBB0_521 $7876(%rip) + WORD $0xd2800011 // mov x17, #0 + WORD $0x9280000a // mov x10, #-1 + WORD $0x4f01e5c0 // movi.16b v0, #46 + WORD $0x4f01e561 // movi.16b v1, #43 + WORD $0x4f01e5a2 // movi.16b v2, #45 + WORD $0x4f06e603 // movi.16b v3, #208 +Lloh2: + WORD $0x10ffeb2b // adr x11, lCPI0_0 $-668(%rip) +Lloh3: + WORD $0x3dc00164 // ldr q4, [x11, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x4f00e545 // movi.16b v5, #10 + WORD $0x4f06e7e6 // movi.16b v6, #223 +Lloh4: + WORD $0x10ffeb2b // adr x11, lCPI0_1 $-668(%rip) +Lloh5: + WORD $0x3dc00167 // ldr q7, [x11, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x4f02e4b0 // movi.16b v16, #69 + WORD $0x12800000 // mov w0, #-1 + WORD $0x9280000c // mov x12, #-1 + WORD $0x9280000b // mov x11, #-1 + WORD $0xaa0f03ed // mov x13, x15 +LBB0_49: + WORD $0x3cf16931 // ldr q17, [x9, x17] + WORD $0x6e208e32 // cmeq.16b v18, v17, v0 + WORD $0x6e218e33 // cmeq.16b v19, v17, v1 + WORD $0x6e228e34 // cmeq.16b v20, v17, v2 + WORD $0x4e238635 // add.16b v21, v17, v3 + WORD $0x6e3534b5 // cmhi.16b v21, v5, v21 + WORD $0x4e261e31 // and.16b v17, v17, v6 + WORD $0x6e308e31 // cmeq.16b v17, v17, v16 + WORD $0x4eb31e93 // orr.16b v19, v20, v19 + WORD $0x4eb21e34 // orr.16b v20, v17, v18 + WORD $0x4eb31e94 // orr.16b v20, v20, v19 + WORD $0x4eb51e94 // orr.16b v20, v20, v21 + WORD $0x4e241e52 // and.16b v18, v18, v4 + WORD $0x4e070252 // tbl.16b v18, { v18 }, v7 + WORD $0x4e71ba52 // addv.8h h18, v18 + WORD $0x1e260242 // fmov w2, s18 + WORD $0x4e241e31 // and.16b v17, v17, v4 + WORD $0x4e070231 // tbl.16b v17, { v17 }, v7 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260224 // fmov w4, s17 + WORD $0x4e241e71 // and.16b v17, v19, v4 + WORD $0x4e070231 // tbl.16b v17, { v17 }, v7 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260226 // fmov w6, s17 + WORD $0x4e241e91 // and.16b v17, v20, v4 + WORD $0x4e070231 // tbl.16b v17, { v17 }, v7 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260221 // fmov w1, s17 + WORD $0x2a2103e1 // mvn w1, w1 + WORD $0x32103c21 // orr w1, w1, #0xffff0000 + WORD $0x5ac00021 // rbit w1, w1 + WORD $0x5ac01021 // clz w1, w1 + WORD $0x1ac12005 // lsl w5, w0, w1 + WORD $0x0a250047 // bic w7, w2, w5 + WORD $0x0a250093 // bic w19, w4, w5 + WORD $0x0a2500d4 // bic w20, w6, w5 + WORD $0x7100403f // cmp w1, #16 + WORD $0x1a870045 // csel w5, w2, w7, eq + WORD $0x1a930084 // csel w4, w4, w19, eq + WORD $0x1a9400c2 // csel w2, w6, w20, eq + WORD $0x510004a6 // sub w6, w5, #1 + WORD $0x6a0500c6 // ands w6, w6, w5 + WORD $0x54004e01 // b.ne LBB0_196 $2496(%rip) + WORD $0x51000486 // sub w6, w4, #1 + WORD $0x6a0400c6 // ands w6, w6, w4 + WORD $0x54004da1 // b.ne LBB0_196 $2484(%rip) + WORD $0x51000446 // sub w6, w2, #1 + WORD $0x6a0200c6 // ands w6, w6, w2 + WORD $0x54004d41 // b.ne LBB0_196 $2472(%rip) + WORD $0x340000c5 // cbz w5, LBB0_55 $24(%rip) + WORD $0x5ac000a5 // rbit w5, w5 + WORD $0x5ac010a5 // clz w5, w5 + WORD $0xb100057f // cmn x11, #1 + WORD $0x54007041 // b.ne LBB0_257 $3592(%rip) + WORD $0x8b05022b // add x11, x17, x5 +LBB0_55: + WORD $0x340000c4 // cbz w4, LBB0_58 $24(%rip) + WORD $0x5ac00084 // rbit w4, w4 + WORD $0x5ac01084 // clz w4, w4 + WORD $0xb100059f // cmn x12, #1 + WORD $0x54006fe1 // b.ne LBB0_258 $3580(%rip) + WORD $0x8b04022c // add x12, x17, x4 +LBB0_58: + WORD $0x340000c2 // cbz w2, LBB0_61 $24(%rip) + WORD $0x5ac00042 // rbit w2, w2 + WORD $0x5ac01042 // clz w2, w2 + WORD $0xb100055f // cmn x10, #1 + WORD $0x54006f81 // b.ne LBB0_259 $3568(%rip) + WORD $0x8b02022a // add x10, x17, x2 +LBB0_61: + WORD $0x7100403f // cmp w1, #16 + WORD $0x540005e1 // b.ne LBB0_73 $188(%rip) + WORD $0xd10041ad // sub x13, x13, #16 + WORD $0x91004231 // add x17, x17, #16 + WORD $0xf1003dbf // cmp x13, #15 + WORD $0x54fff708 // b.hi LBB0_49 $-288(%rip) + WORD $0x8b110120 // add x0, x9, x17 + WORD $0xeb1101ff // cmp x15, x17 + WORD $0x54000540 // b.eq LBB0_74 $168(%rip) +LBB0_64: + WORD $0x8b0d000f // add x15, x0, x13 + WORD $0x8b0801d1 // add x17, x14, x8 + WORD $0x8b100230 // add x16, x17, x16 + WORD $0xaa2003f1 // mvn x17, x0 + WORD $0x8b100231 // add x17, x17, x16 + WORD $0xcb090010 // sub x16, x0, x9 + WORD $0xaa0003e1 // mov x1, x0 +Lloh6: + WORD $0x10012042 // adr x2, LJTI0_1 $9224(%rip) +Lloh7: + WORD $0x91000042 // add x2, x2, LJTI0_1@PAGEOFF $0(%rip) + WORD $0x1400000b // b LBB0_68 $44(%rip) +LBB0_65: + WORD $0x7101949f // cmp w4, #101 + WORD $0x540003c1 // b.ne LBB0_74 $120(%rip) +LBB0_66: + WORD $0xb100059f // cmn x12, #1 + WORD $0xaa1003ec // mov x12, x16 + WORD $0x54004881 // b.ne LBB0_197 $2320(%rip) +LBB0_67: + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0x91000610 // add x16, x16, #1 + WORD $0xaa0103e0 // mov x0, x1 + WORD $0xd10005ad // sub x13, x13, #1 + WORD $0xb40039ad // cbz x13, LBB0_158 $1844(%rip) +LBB0_68: + WORD $0x38c01424 // ldrsb w4, [x1], #1 + WORD $0x5100c085 // sub w5, w4, #48 + WORD $0x710028bf // cmp w5, #10 + WORD $0x54ffff03 // b.lo LBB0_67 $-32(%rip) + WORD $0x5100ac85 // sub w5, w4, #43 + WORD $0x710068bf // cmp w5, #26 + WORD $0x54fffe08 // b.hi LBB0_65 $-64(%rip) + WORD $0x10fffe24 // adr x4, LBB0_66 $-60(%rip) + WORD $0x38656846 // ldrb w6, [x2, x5] + WORD $0x8b060884 // add x4, x4, x6, lsl #2 + WORD $0xd61f0080 // br x4 +LBB0_71: + WORD $0xb100055f // cmn x10, #1 + WORD $0xaa1003ea // mov x10, x16 + WORD $0x54fffdc0 // b.eq LBB0_67 $-72(%rip) + WORD $0x14000230 // b LBB0_197 $2240(%rip) +LBB0_72: + WORD $0xb100057f // cmn x11, #1 + WORD $0xaa1003eb // mov x11, x16 + WORD $0x54fffd40 // b.eq LBB0_67 $-88(%rip) + WORD $0x1400022c // b LBB0_197 $2224(%rip) +LBB0_73: + WORD $0x8b21412d // add x13, x9, w1, uxtw + WORD $0x8b1101a0 // add x0, x13, x17 +LBB0_74: + WORD $0x92800011 // mov x17, #-1 + WORD $0xb400372b // cbz x11, LBB0_159 $1764(%rip) +LBB0_75: + WORD $0xb400370a // cbz x10, LBB0_159 $1760(%rip) + WORD $0xb40036ec // cbz x12, LBB0_159 $1756(%rip) + WORD $0xcb09000d // sub x13, x0, x9 + WORD $0xd10005af // sub x15, x13, #1 + WORD $0xeb0f017f // cmp x11, x15 + WORD $0x54001cc0 // b.eq LBB0_123 $920(%rip) + WORD $0xeb0f015f // cmp x10, x15 + WORD $0x54001c80 // b.eq LBB0_123 $912(%rip) + WORD $0xeb0f019f // cmp x12, x15 + WORD $0x54001c40 // b.eq LBB0_123 $904(%rip) + WORD $0xf100054f // subs x15, x10, #1 + WORD $0x54002d6b // b.lt LBB0_137 $1452(%rip) + WORD $0xeb0f019f // cmp x12, x15 + WORD $0x54002d20 // b.eq LBB0_137 $1444(%rip) + WORD $0xaa2a03f1 // mvn x17, x10 + WORD $0x14000218 // b LBB0_197 $2144(%rip) +LBB0_83: + WORD $0x7100c21f // cmp w16, #48 + WORD $0x540001c1 // b.ne LBB0_87 $56(%rip) + WORD $0x91000440 // add x0, x2, #1 + WORD $0xeb01005f // cmp x2, x1 + WORD $0x54ffe722 // b.hs LBB0_36 $-796(%rip) + WORD $0x3860690c // ldrb w12, [x8, x0] + WORD $0x5100b98c // sub w12, w12, #46 + WORD $0x7100dd9f // cmp w12, #55 + WORD $0x54ffe6a8 // b.hi LBB0_36 $-812(%rip) + WORD $0x52800031 // mov w17, #1 + WORD $0x9acc222c // lsl x12, x17, x12 + WORD $0xb20903f1 // mov x17, #36028797027352576 + WORD $0xf2800031 // movk x17, #1 + WORD $0xea11019f // tst x12, x17 + WORD $0x54ffe5e0 // b.eq LBB0_36 $-836(%rip) +LBB0_87: + WORD $0xeb01005f // cmp x2, x1 + WORD $0x54002b82 // b.hs LBB0_140 $1392(%rip) + WORD $0x52800011 // mov w17, #0 + WORD $0x52800000 // mov w0, #0 + WORD $0xd280000c // mov x12, #0 + WORD $0x128005e4 // mov w4, #-48 + WORD $0x91000442 // add x2, x2, #1 + WORD $0x52800145 // mov w5, #10 +LBB0_89: + WORD $0x7100481f // cmp w0, #18 + WORD $0x0b300090 // add w16, w4, w16, uxtb + WORD $0x9b054190 // madd x16, x12, x5, x16 + WORD $0x1a91d631 // cinc w17, w17, gt + WORD $0x1a80c400 // cinc w0, w0, le + WORD $0x9a90c18c // csel x12, x12, x16, gt + WORD $0xeb02003f // cmp x1, x2 + WORD $0x540032e0 // b.eq LBB0_163 $1628(%rip) + WORD $0x38626910 // ldrb w16, [x8, x2] + WORD $0x5100c206 // sub w6, w16, #48 + WORD $0x91000442 // add x2, x2, #1 + WORD $0x710028df // cmp w6, #10 + WORD $0x54fffe83 // b.lo LBB0_89 $-48(%rip) + WORD $0x7100ba1f // cmp w16, #46 + WORD $0x54004101 // b.ne LBB0_201 $2080(%rip) + WORD $0x52800110 // mov w16, #8 + WORD $0xf9000070 // str x16, [x3] + WORD $0xeb01005f // cmp x2, x1 + WORD $0x54003b62 // b.hs LBB0_191 $1900(%rip) + WORD $0x38626910 // ldrb w16, [x8, x2] + WORD $0x5100ea10 // sub w16, w16, #58 + WORD $0x31002e1f // cmn w16, #11 + WORD $0x54ffe589 // b.ls LBB0_44 $-848(%rip) + WORD $0x52800004 // mov w4, #0 + WORD $0x14000188 // b LBB0_164 $1568(%rip) +LBB0_95: + WORD $0xf261009f // tst x4, #0x80000000 + WORD $0x1a9f17e8 // cset w8, eq + WORD $0x52800169 // mov w9, #11 + WORD $0x14000091 // b LBB0_118 $580(%rip) +LBB0_96: + WORD $0xd1000c29 // sub x9, x1, #3 + WORD $0xeb0901df // cmp x14, x9 + WORD $0x540039c2 // b.hs LBB0_191 $1848(%rip) + WORD $0xb94001e9 // ldr w9, [x15] + WORD $0x528eadca // mov w10, #30062 + WORD $0x72ad8d8a // movk w10, #27756, lsl #16 + WORD $0x6b0a013f // cmp w9, w10 + WORD $0x540026c1 // b.ne LBB0_142 $1240(%rip) + WORD $0x910011c1 // add x1, x14, #4 + WORD $0x52800048 // mov w8, #2 + WORD $0x140001c7 // b LBB0_192 $1820(%rip) +LBB0_99: + WORD $0xf261009f // tst x4, #0x80000000 + WORD $0x1a9f17e8 // cset w8, eq + WORD $0x528001a9 // mov w9, #13 + WORD $0x14000082 // b LBB0_118 $520(%rip) +LBB0_100: + WORD $0x92800028 // mov x8, #-2 + WORD $0xf9000068 // str x8, [x3] + WORD $0xaa0e03e0 // mov x0, x14 + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret +LBB0_101: + WORD $0xeb01005f // cmp x2, x1 + WORD $0x37281204 // tbnz w4, #5, LBB0_124 $576(%rip) + WORD $0x540107e0 // b.eq LBB0_621 $8444(%rip) + WORD $0xcb02002b // sub x11, x1, x2 + WORD $0xf101017f // cmp x11, #64 + WORD $0x5400f483 // b.lo LBB0_583 $7824(%rip) + WORD $0xd280000c // mov x12, #0 + WORD $0x92800009 // mov x9, #-1 + WORD $0x4f01e440 // movi.16b v0, #34 + WORD $0x4f02e781 // movi.16b v1, #92 +Lloh8: + WORD $0x10ffce2a // adr x10, lCPI0_0 $-1596(%rip) +Lloh9: + WORD $0x3dc00142 // ldr q2, [x10, lCPI0_0@PAGEOFF] $0(%rip) +Lloh10: + WORD $0x10ffce6a // adr x10, lCPI0_1 $-1588(%rip) +Lloh11: + WORD $0x3dc00143 // ldr q3, [x10, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0xaa0203ed // mov x13, x2 + WORD $0x9280000a // mov x10, #-1 +LBB0_105: + WORD $0x8b0d010e // add x14, x8, x13 + WORD $0xad4015c4 // ldp q4, q5, [x14] + WORD $0xad411dc6 // ldp q6, q7, [x14, #32] + WORD $0x6e208c90 // cmeq.16b v16, v4, v0 + WORD $0x6e208cb1 // cmeq.16b v17, v5, v0 + WORD $0x6e208cd2 // cmeq.16b v18, v6, v0 + WORD $0x6e208cf3 // cmeq.16b v19, v7, v0 + WORD $0x6e218c84 // cmeq.16b v4, v4, v1 + WORD $0x6e218ca5 // cmeq.16b v5, v5, v1 + WORD $0x6e218cc6 // cmeq.16b v6, v6, v1 + WORD $0x6e218ce7 // cmeq.16b v7, v7, v1 + WORD $0x4e221e10 // and.16b v16, v16, v2 + WORD $0x4e030210 // tbl.16b v16, { v16 }, v3 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e26020e // fmov w14, s16 + WORD $0x4e221e30 // and.16b v16, v17, v2 + WORD $0x4e030210 // tbl.16b v16, { v16 }, v3 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e26020f // fmov w15, s16 + WORD $0x4e221e50 // and.16b v16, v18, v2 + WORD $0x4e030210 // tbl.16b v16, { v16 }, v3 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e260210 // fmov w16, s16 + WORD $0x4e221e70 // and.16b v16, v19, v2 + WORD $0x4e030210 // tbl.16b v16, { v16 }, v3 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e260211 // fmov w17, s16 + WORD $0x4e221c84 // and.16b v4, v4, v2 + WORD $0x4e030084 // tbl.16b v4, { v4 }, v3 + WORD $0x4e71b884 // addv.8h h4, v4 + WORD $0x1e260080 // fmov w0, s4 + WORD $0x4e221ca4 // and.16b v4, v5, v2 + WORD $0x4e030084 // tbl.16b v4, { v4 }, v3 + WORD $0x4e71b884 // addv.8h h4, v4 + WORD $0x1e260084 // fmov w4, s4 + WORD $0x4e221cc4 // and.16b v4, v6, v2 + WORD $0x4e030084 // tbl.16b v4, { v4 }, v3 + WORD $0x4e71b884 // addv.8h h4, v4 + WORD $0x1e260085 // fmov w5, s4 + WORD $0x4e221ce4 // and.16b v4, v7, v2 + WORD $0x4e030084 // tbl.16b v4, { v4 }, v3 + WORD $0x4e71b884 // addv.8h h4, v4 + WORD $0x1e260086 // fmov w6, s4 + WORD $0xd3607e10 // lsl x16, x16, #32 + WORD $0xb3503e30 // bfi x16, x17, #48, #16 + WORD $0x53103def // lsl w15, w15, #16 + WORD $0xaa0f020f // orr x15, x16, x15 + WORD $0xaa0e01ee // orr x14, x15, x14 + WORD $0xd3607caf // lsl x15, x5, #32 + WORD $0xb3503ccf // bfi x15, x6, #48, #16 + WORD $0x53103c90 // lsl w16, w4, #16 + WORD $0xaa1001ef // orr x15, x15, x16 + WORD $0xaa0001ef // orr x15, x15, x0 + WORD $0xb500010f // cbnz x15, LBB0_109 $32(%rip) + WORD $0xb50001ac // cbnz x12, LBB0_110 $52(%rip) + WORD $0xb50002ee // cbnz x14, LBB0_111 $92(%rip) +LBB0_108: + WORD $0xd101016b // sub x11, x11, #64 + WORD $0x910101ad // add x13, x13, #64 + WORD $0xf100fd7f // cmp x11, #63 + WORD $0x54fff8a8 // b.hi LBB0_105 $-236(%rip) + WORD $0x140002a4 // b LBB0_261 $2704(%rip) +LBB0_109: + WORD $0xb100055f // cmn x10, #1 + WORD $0xdac001f0 // rbit x16, x15 + WORD $0xdac01210 // clz x16, x16 + WORD $0x8b0d0210 // add x16, x16, x13 + WORD $0x9a901129 // csel x9, x9, x16, ne + WORD $0x9a90114a // csel x10, x10, x16, ne +LBB0_110: + WORD $0x8a2c01f0 // bic x16, x15, x12 + WORD $0xaa100591 // orr x17, x12, x16, lsl #1 + WORD $0x8a3101ec // bic x12, x15, x17 + WORD $0x9201f18c // and x12, x12, #0xaaaaaaaaaaaaaaaa + WORD $0xab10018f // adds x15, x12, x16 + WORD $0x1a9f37ec // cset w12, hs + WORD $0xd37ff9ef // lsl x15, x15, #1 + WORD $0xd200f1ef // eor x15, x15, #0x5555555555555555 + WORD $0x8a1101ef // and x15, x15, x17 + WORD $0x8a2f01ce // bic x14, x14, x15 + WORD $0xb4fffd6e // cbz x14, LBB0_108 $-84(%rip) +LBB0_111: + WORD $0xdac001c8 // rbit x8, x14 + WORD $0xdac01108 // clz x8, x8 + WORD $0x8b0d0108 // add x8, x8, x13 + WORD $0x91000500 // add x0, x8, #1 + WORD $0xb6f815a0 // tbz x0, #63, LBB0_136 $692(%rip) + WORD $0x140007c6 // b LBB0_615 $7960(%rip) +LBB0_112: + WORD $0xf261009f // tst x4, #0x80000000 + WORD $0x1a9f17e8 // cset w8, eq + WORD $0x52800149 // mov w9, #10 + WORD $0x14000011 // b LBB0_118 $68(%rip) +LBB0_113: + WORD $0x528000a8 // mov w8, #5 + WORD $0x17fffe86 // b LBB0_35 $-1512(%rip) +LBB0_114: + WORD $0xd1000c29 // sub x9, x1, #3 + WORD $0xeb0901df // cmp x14, x9 + WORD $0x54002982 // b.hs LBB0_191 $1328(%rip) + WORD $0xb94001e9 // ldr w9, [x15] + WORD $0x528e4e8a // mov w10, #29300 + WORD $0x72acaeaa // movk w10, #25973, lsl #16 + WORD $0x6b0a013f // cmp w9, w10 + WORD $0x54001881 // b.ne LBB0_146 $784(%rip) + WORD $0x910011c1 // add x1, x14, #4 + WORD $0x52800068 // mov w8, #3 + WORD $0x14000145 // b LBB0_192 $1300(%rip) +LBB0_117: + WORD $0xf261009f // tst x4, #0x80000000 + WORD $0x1a9f17e8 // cset w8, eq + WORD $0x52800189 // mov w9, #12 +LBB0_118: + WORD $0x9280002a // mov x10, #-2 + WORD $0x9a890149 // csel x9, x10, x9, eq + WORD $0xf9000069 // str x9, [x3] + WORD $0xcb080040 // sub x0, x2, x8 + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret +LBB0_119: + WORD $0xd1001029 // sub x9, x1, #4 + WORD $0xeb0901df // cmp x14, x9 + WORD $0x54002682 // b.hs LBB0_191 $1232(%rip) + WORD $0xb8626909 // ldr w9, [x8, x2] + WORD $0x528d8c2a // mov w10, #27745 + WORD $0x72acae6a // movk w10, #25971, lsl #16 + WORD $0x6b0a013f // cmp w9, w10 + WORD $0x540017c1 // b.ne LBB0_151 $760(%rip) + WORD $0x910015c1 // add x1, x14, #5 + WORD $0x52800088 // mov w8, #4 + WORD $0x1400012d // b LBB0_192 $1204(%rip) +LBB0_122: + WORD $0x528000c8 // mov w8, #6 + WORD $0x17fffe61 // b LBB0_35 $-1660(%rip) +LBB0_123: + WORD $0xcb0d03f1 // neg x17, x13 + WORD $0x1400013b // b LBB0_197 $1260(%rip) +LBB0_124: + WORD $0x5400f600 // b.eq LBB0_621 $7872(%rip) + WORD $0xcb02002b // sub x11, x1, x2 + WORD $0xf101017f // cmp x11, #64 + WORD $0x5400e383 // b.lo LBB0_584 $7280(%rip) + WORD $0xd280000a // mov x10, #0 + WORD $0x92800009 // mov x9, #-1 + WORD $0x4f01e440 // movi.16b v0, #34 +Lloh12: + WORD $0x10ffbc6c // adr x12, lCPI0_0 $-2164(%rip) +Lloh13: + WORD $0x3dc00181 // ldr q1, [x12, lCPI0_0@PAGEOFF] $0(%rip) +Lloh14: + WORD $0x10ffbcac // adr x12, lCPI0_1 $-2156(%rip) +Lloh15: + WORD $0x3dc00182 // ldr q2, [x12, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x4f02e783 // movi.16b v3, #92 + WORD $0x4f01e404 // movi.16b v4, #32 + WORD $0xaa0203ec // mov x12, x2 +LBB0_127: + WORD $0x8b0c010d // add x13, x8, x12 + WORD $0xad401db0 // ldp q16, q7, [x13] + WORD $0xad4115a6 // ldp q6, q5, [x13, #32] + WORD $0x6e208e11 // cmeq.16b v17, v16, v0 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e26022d // fmov w13, s17 + WORD $0x6e208cf1 // cmeq.16b v17, v7, v0 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e26022e // fmov w14, s17 + WORD $0x6e208cd1 // cmeq.16b v17, v6, v0 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e26022f // fmov w15, s17 + WORD $0x6e208cb1 // cmeq.16b v17, v5, v0 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260230 // fmov w16, s17 + WORD $0x6e238e11 // cmeq.16b v17, v16, v3 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260231 // fmov w17, s17 + WORD $0x6e238cf1 // cmeq.16b v17, v7, v3 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260220 // fmov w0, s17 + WORD $0x6e238cd1 // cmeq.16b v17, v6, v3 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260224 // fmov w4, s17 + WORD $0x6e238cb1 // cmeq.16b v17, v5, v3 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260225 // fmov w5, s17 + WORD $0xd3607def // lsl x15, x15, #32 + WORD $0xb3503e0f // bfi x15, x16, #48, #16 + WORD $0x53103dce // lsl w14, w14, #16 + WORD $0xaa0e01ee // orr x14, x15, x14 + WORD $0xaa0d01cd // orr x13, x14, x13 + WORD $0xd3607c8e // lsl x14, x4, #32 + WORD $0xb3503cae // bfi x14, x5, #48, #16 + WORD $0x53103c0f // lsl w15, w0, #16 + WORD $0xaa0f01ce // orr x14, x14, x15 + WORD $0xaa1101ce // orr x14, x14, x17 + WORD $0xb500044e // cbnz x14, LBB0_132 $136(%rip) + WORD $0xb50004ca // cbnz x10, LBB0_133 $152(%rip) +LBB0_129: + WORD $0x6e303490 // cmhi.16b v16, v4, v16 + WORD $0x4e211e10 // and.16b v16, v16, v1 + WORD $0x4e020210 // tbl.16b v16, { v16 }, v2 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e26020e // fmov w14, s16 + WORD $0x6e273487 // cmhi.16b v7, v4, v7 + WORD $0x4e211ce7 // and.16b v7, v7, v1 + WORD $0x4e0200e7 // tbl.16b v7, { v7 }, v2 + WORD $0x4e71b8e7 // addv.8h h7, v7 + WORD $0x1e2600ef // fmov w15, s7 + WORD $0x6e263486 // cmhi.16b v6, v4, v6 + WORD $0x4e211cc6 // and.16b v6, v6, v1 + WORD $0x4e0200c6 // tbl.16b v6, { v6 }, v2 + WORD $0x4e71b8c6 // addv.8h h6, v6 + WORD $0x1e2600d0 // fmov w16, s6 + WORD $0x6e253485 // cmhi.16b v5, v4, v5 + WORD $0x4e211ca5 // and.16b v5, v5, v1 + WORD $0x4e0200a5 // tbl.16b v5, { v5 }, v2 + WORD $0x4e71b8a5 // addv.8h h5, v5 + WORD $0x1e2600b1 // fmov w17, s5 + WORD $0xd3607e10 // lsl x16, x16, #32 + WORD $0xb3503e30 // bfi x16, x17, #48, #16 + WORD $0x53103def // lsl w15, w15, #16 + WORD $0xaa0f020f // orr x15, x16, x15 + WORD $0xaa0e01ee // orr x14, x15, x14 + WORD $0xb50002ed // cbnz x13, LBB0_134 $92(%rip) + WORD $0xb500e70e // cbnz x14, LBB0_614 $7392(%rip) + WORD $0xd101016b // sub x11, x11, #64 + WORD $0x9101018c // add x12, x12, #64 + WORD $0xf100fd7f // cmp x11, #63 + WORD $0x54fff568 // b.hi LBB0_127 $-340(%rip) + WORD $0x14000222 // b LBB0_266 $2184(%rip) +LBB0_132: + WORD $0xb100053f // cmn x9, #1 + WORD $0xdac001cf // rbit x15, x14 + WORD $0xdac011ef // clz x15, x15 + WORD $0x8b0c01ef // add x15, x15, x12 + WORD $0x9a8f1129 // csel x9, x9, x15, ne +LBB0_133: + WORD $0x8a2a01cf // bic x15, x14, x10 + WORD $0xaa0f0550 // orr x16, x10, x15, lsl #1 + WORD $0x8a3001ca // bic x10, x14, x16 + WORD $0x9201f14a // and x10, x10, #0xaaaaaaaaaaaaaaaa + WORD $0xab0f014e // adds x14, x10, x15 + WORD $0x1a9f37ea // cset w10, hs + WORD $0xd37ff9ce // lsl x14, x14, #1 + WORD $0xd200f1ce // eor x14, x14, #0x5555555555555555 + WORD $0x8a1001ce // and x14, x14, x16 + WORD $0x8a2e01ad // bic x13, x13, x14 + WORD $0x17ffffd1 // b LBB0_129 $-188(%rip) +LBB0_134: + WORD $0xdac001a8 // rbit x8, x13 + WORD $0xdac01108 // clz x8, x8 + WORD $0xdac001ca // rbit x10, x14 + WORD $0xdac0114a // clz x10, x10 + WORD $0xeb08015f // cmp x10, x8 + WORD $0x5400e3a3 // b.lo LBB0_614 $7284(%rip) + WORD $0x8b0c0108 // add x8, x8, x12 + WORD $0x91000500 // add x0, x8, #1 + WORD $0xb7f8e360 // tbnz x0, #63, LBB0_615 $7276(%rip) +LBB0_136: + WORD $0x528000e8 // mov w8, #7 + WORD $0xf9000068 // str x8, [x3] + WORD $0xeb00013f // cmp x9, x0 + WORD $0xda9fb128 // csinv x8, x9, xzr, lt + WORD $0xa9012062 // stp x2, x8, [x3, #16] + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret +LBB0_137: + WORD $0xaa0c016a // orr x10, x11, x12 + WORD $0xb7f808ca // tbnz x10, #63, LBB0_162 $280(%rip) + WORD $0xeb0c017f // cmp x11, x12 + WORD $0x5400088b // b.lt LBB0_162 $272(%rip) + WORD $0xaa2b03f1 // mvn x17, x11 + WORD $0x140000ac // b LBB0_197 $688(%rip) +LBB0_140: + WORD $0x52800011 // mov w17, #0 + WORD $0x52800000 // mov w0, #0 + WORD $0xd280000c // mov x12, #0 +LBB0_141: + WORD $0x52800024 // mov w4, #1 + WORD $0x14000047 // b LBB0_164 $284(%rip) +LBB0_142: + WORD $0x12001d29 // and w9, w9, #0xff + WORD $0x7101b93f // cmp w9, #110 + WORD $0x540003a1 // b.ne LBB0_150 $116(%rip) + WORD $0x910005c1 // add x1, x14, #1 + WORD $0x38616909 // ldrb w9, [x8, x1] + WORD $0x7101d53f // cmp w9, #117 + WORD $0x54000581 // b.ne LBB0_157 $176(%rip) + WORD $0x910009c1 // add x1, x14, #2 + WORD $0x38616909 // ldrb w9, [x8, x1] + WORD $0x7101b13f // cmp w9, #108 + WORD $0x54000501 // b.ne LBB0_157 $160(%rip) + WORD $0x91000dc9 // add x9, x14, #3 + WORD $0x38696908 // ldrb w8, [x8, x9] + WORD $0x910011ca // add x10, x14, #4 + WORD $0x7101b11f // cmp w8, #108 + WORD $0x14000022 // b LBB0_156 $136(%rip) +LBB0_146: + WORD $0x12001d29 // and w9, w9, #0xff + WORD $0x7101d13f // cmp w9, #116 + WORD $0x540001a1 // b.ne LBB0_150 $52(%rip) + WORD $0x910005c1 // add x1, x14, #1 + WORD $0x38616909 // ldrb w9, [x8, x1] + WORD $0x7101c93f // cmp w9, #114 + WORD $0x54000381 // b.ne LBB0_157 $112(%rip) + WORD $0x910009c1 // add x1, x14, #2 + WORD $0x38616909 // ldrb w9, [x8, x1] + WORD $0x7101d53f // cmp w9, #117 + WORD $0x54000301 // b.ne LBB0_157 $96(%rip) + WORD $0x91000dc9 // add x9, x14, #3 + WORD $0x38696908 // ldrb w8, [x8, x9] + WORD $0x910011ca // add x10, x14, #4 + WORD $0x14000012 // b LBB0_155 $72(%rip) +LBB0_150: + WORD $0x92800028 // mov x8, #-2 + WORD $0xaa0e03e1 // mov x1, x14 + WORD $0x14000073 // b LBB0_192 $460(%rip) +LBB0_151: + WORD $0x12001d29 // and w9, w9, #0xff + WORD $0x7101853f // cmp w9, #97 + WORD $0x54000f61 // b.ne LBB0_195 $492(%rip) + WORD $0x910009c1 // add x1, x14, #2 + WORD $0x38616909 // ldrb w9, [x8, x1] + WORD $0x7101b13f // cmp w9, #108 + WORD $0x54000141 // b.ne LBB0_157 $40(%rip) + WORD $0x91000dc1 // add x1, x14, #3 + WORD $0x38616909 // ldrb w9, [x8, x1] + WORD $0x7101cd3f // cmp w9, #115 + WORD $0x540000c1 // b.ne LBB0_157 $24(%rip) + WORD $0x910011c9 // add x9, x14, #4 + WORD $0x38696908 // ldrb w8, [x8, x9] + WORD $0x910015ca // add x10, x14, #5 +LBB0_155: + WORD $0x7101951f // cmp w8, #101 +LBB0_156: + WORD $0x9a890141 // csel x1, x10, x9, eq +LBB0_157: + WORD $0x92800028 // mov x8, #-2 + WORD $0x14000061 // b LBB0_192 $388(%rip) +LBB0_158: + WORD $0xaa0f03e0 // mov x0, x15 + WORD $0x92800011 // mov x17, #-1 + WORD $0xb5ffc92b // cbnz x11, LBB0_75 $-1756(%rip) +LBB0_159: + WORD $0xaa3103ea // mvn x10, x17 + WORD $0x8b0a0129 // add x9, x9, x10 +LBB0_160: + WORD $0x9280002e // mov x14, #-2 +LBB0_161: + WORD $0xcb080120 // sub x0, x9, x8 + WORD $0x14000071 // b LBB0_199 $452(%rip) +LBB0_162: + WORD $0xd37ffd4a // lsr x10, x10, #63 + WORD $0x5200014a // eor w10, w10, #0x1 + WORD $0xd100058f // sub x15, x12, #1 + WORD $0xeb0f017f // cmp x11, x15 + WORD $0x1a9f17eb // cset w11, eq + WORD $0x6a0b015f // tst w10, w11 + WORD $0xda8c01b1 // csinv x17, x13, x12, eq + WORD $0x14000063 // b LBB0_197 $396(%rip) +LBB0_163: + WORD $0x52800024 // mov w4, #1 + WORD $0xaa0103e2 // mov x2, x1 +LBB0_164: + WORD $0x7100023f // cmp w17, #0 + WORD $0x1a9fd7f0 // cset w16, gt + WORD $0xb500024c // cbnz x12, LBB0_173 $72(%rip) + WORD $0x35000231 // cbnz w17, LBB0_173 $68(%rip) + WORD $0xeb01005f // cmp x2, x1 + WORD $0x54000182 // b.hs LBB0_171 $48(%rip) + WORD $0x52800011 // mov w17, #0 + WORD $0x4b010045 // sub w5, w2, w1 +LBB0_168: + WORD $0x3862690c // ldrb w12, [x8, x2] + WORD $0x7100c19f // cmp w12, #48 + WORD $0x54000101 // b.ne LBB0_172 $32(%rip) + WORD $0x91000442 // add x2, x2, #1 + WORD $0x51000631 // sub w17, w17, #1 + WORD $0xeb02003f // cmp x1, x2 + WORD $0x54ffff41 // b.ne LBB0_168 $-24(%rip) + WORD $0xd280000c // mov x12, #0 + WORD $0x1400006a // b LBB0_203 $424(%rip) +LBB0_171: + WORD $0x52800011 // mov w17, #0 +LBB0_172: + WORD $0x52800000 // mov w0, #0 + WORD $0xd280000c // mov x12, #0 +LBB0_173: + WORD $0xeb01005f // cmp x2, x1 + WORD $0x54000262 // b.hs LBB0_179 $76(%rip) + WORD $0x7100481f // cmp w0, #18 + WORD $0x5400022c // b.gt LBB0_179 $68(%rip) + WORD $0x128005e5 // mov w5, #-48 + WORD $0x52800146 // mov w6, #10 +LBB0_176: + WORD $0x38626907 // ldrb w7, [x8, x2] + WORD $0x5100c0f3 // sub w19, w7, #48 + WORD $0x7100267f // cmp w19, #9 + WORD $0x54000168 // b.hi LBB0_179 $44(%rip) + WORD $0x0b0500e7 // add w7, w7, w5 + WORD $0x9b061d8c // madd x12, x12, x6, x7 + WORD $0x51000631 // sub w17, w17, #1 + WORD $0x91000442 // add x2, x2, #1 + WORD $0xeb01005f // cmp x2, x1 + WORD $0x540000a2 // b.hs LBB0_179 $20(%rip) + WORD $0x11000407 // add w7, w0, #1 + WORD $0x7100481f // cmp w0, #18 + WORD $0xaa0703e0 // mov x0, x7 + WORD $0x54fffe6b // b.lt LBB0_176 $-52(%rip) +LBB0_179: + WORD $0xeb01005f // cmp x2, x1 + WORD $0x540005a2 // b.hs LBB0_194 $180(%rip) + WORD $0x38626900 // ldrb w0, [x8, x2] + WORD $0x5100c005 // sub w5, w0, #48 + WORD $0x710024bf // cmp w5, #9 + WORD $0x54000168 // b.hi LBB0_185 $44(%rip) + WORD $0x91000510 // add x16, x8, #1 + WORD $0xd1000425 // sub x5, x1, #1 +LBB0_182: + WORD $0xeb0200bf // cmp x5, x2 + WORD $0x540008e0 // b.eq LBB0_202 $284(%rip) + WORD $0x38626a00 // ldrb w0, [x16, x2] + WORD $0x5100c006 // sub w6, w0, #48 + WORD $0x91000442 // add x2, x2, #1 + WORD $0x710024df // cmp w6, #9 + WORD $0x54ffff49 // b.ls LBB0_182 $-24(%rip) + WORD $0x52800030 // mov w16, #1 +LBB0_185: + WORD $0x321b0000 // orr w0, w0, #0x20 + WORD $0x7101941f // cmp w0, #101 + WORD $0x54000381 // b.ne LBB0_194 $112(%rip) + WORD $0x91000440 // add x0, x2, #1 + WORD $0x52800104 // mov w4, #8 + WORD $0xf9000064 // str x4, [x3] + WORD $0xeb01001f // cmp x0, x1 + WORD $0x540001c2 // b.hs LBB0_191 $56(%rip) + WORD $0x38606904 // ldrb w4, [x8, x0] + WORD $0x7100b49f // cmp w4, #45 + WORD $0x54000060 // b.eq LBB0_189 $12(%rip) + WORD $0x7100ac9f // cmp w4, #43 + WORD $0x54001fa1 // b.ne LBB0_242 $1012(%rip) +LBB0_189: + WORD $0x91000840 // add x0, x2, #2 + WORD $0xeb01001f // cmp x0, x1 + WORD $0x540000c2 // b.hs LBB0_191 $24(%rip) + WORD $0x7100ac9f // cmp w4, #43 + WORD $0x52800022 // mov w2, #1 + WORD $0x5a820442 // cneg w2, w2, ne + WORD $0x38606904 // ldrb w4, [x8, x0] + WORD $0x140000f6 // b LBB0_243 $984(%rip) +LBB0_191: + WORD $0x92800008 // mov x8, #-1 +LBB0_192: + WORD $0xf9000068 // str x8, [x3] +LBB0_193: + WORD $0xaa0103e0 // mov x0, x1 + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret +LBB0_194: + WORD $0xaa1103e5 // mov x5, x17 + WORD $0xaa0203e0 // mov x0, x2 + WORD $0x14000023 // b LBB0_204 $140(%rip) +LBB0_195: + WORD $0x92800028 // mov x8, #-2 + WORD $0xaa0203e1 // mov x1, x2 + WORD $0x17fffff3 // b LBB0_192 $-52(%rip) +LBB0_196: + WORD $0x5ac000ca // rbit w10, w6 + WORD $0x5ac0114a // clz w10, w10 + WORD $0xaa3103eb // mvn x11, x17 + WORD $0xcb0a0171 // sub x17, x11, x10 +LBB0_197: + WORD $0xb7fff231 // tbnz x17, #63, LBB0_159 $-444(%rip) +LBB0_198: + WORD $0x8b110129 // add x9, x9, x17 + WORD $0xcb080120 // sub x0, x9, x8 + WORD $0x92f00008 // mov x8, #9223372036854775807 + WORD $0xeb0801df // cmp x14, x8 + WORD $0x54000103 // b.lo LBB0_200 $32(%rip) +LBB0_199: + WORD $0xf900006e // str x14, [x3] + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret +LBB0_200: + WORD $0x52800108 // mov w8, #8 + WORD $0xf9000068 // str x8, [x3] + WORD $0xf9000c6e // str x14, [x3, #24] + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret +LBB0_201: + WORD $0xd1000442 // sub x2, x2, #1 + WORD $0x17ffff41 // b LBB0_141 $-764(%rip) +LBB0_202: + WORD $0x52800030 // mov w16, #1 + WORD $0xaa1103e5 // mov x5, x17 +LBB0_203: + WORD $0xaa0103e0 // mov x0, x1 +LBB0_204: + WORD $0x34000144 // cbz w4, LBB0_209 $40(%rip) + WORD $0x350000e5 // cbnz w5, LBB0_208 $28(%rip) + WORD $0x93407db1 // sxtw x17, w13 + WORD $0xb6f80e4c // tbz x12, #63, LBB0_228 $456(%rip) + WORD $0x8a110181 // and x1, x12, x17 + WORD $0xd2f00002 // mov x2, #-9223372036854775808 + WORD $0xeb02003f // cmp x1, x2 + WORD $0x54000dc0 // b.eq LBB0_228 $440(%rip) +LBB0_208: + WORD $0x52800111 // mov w17, #8 + WORD $0xf9000071 // str x17, [x3] +LBB0_209: + WORD $0xd374fd91 // lsr x17, x12, #52 + WORD $0xb5000591 // cbnz x17, LBB0_219 $176(%rip) + WORD $0x9e630180 // ucvtf d0, x12 + WORD $0x9e660011 // fmov x17, d0 + WORD $0x531f7dad // lsr w13, w13, #31 + WORD $0xaa0dfe2d // orr x13, x17, x13, lsl #63 + WORD $0x9e6701a0 // fmov d0, x13 + WORD $0xb4003aec // cbz x12, LBB0_310 $1884(%rip) + WORD $0x34003ac5 // cbz w5, LBB0_310 $1880(%rip) + WORD $0x510004ad // sub w13, w5, #1 + WORD $0x710091bf // cmp w13, #36 + WORD $0x54000348 // b.hi LBB0_217 $104(%rip) + WORD $0xaa0503ed // mov x13, x5 + WORD $0x71005cbf // cmp w5, #23 + WORD $0x540000e3 // b.lo LBB0_215 $28(%rip) + WORD $0x510058ad // sub w13, w5, #22 +Lloh16: + WORD $0x1000d171 // adr x17, _P10_TAB $6700(%rip) +Lloh17: + WORD $0x91000231 // add x17, x17, _P10_TAB@PAGEOFF $0(%rip) + WORD $0xfc6d5a21 // ldr d1, [x17, w13, uxtw #3] + WORD $0x1e600820 // fmul d0, d1, d0 + WORD $0x528002cd // mov w13, #22 +LBB0_215: + WORD $0xd2a4c691 // mov x17, #640942080 + WORD $0xf2cd7eb1 // movk x17, #27637, lsl #32 + WORD $0xf2e86191 // movk x17, #17164, lsl #48 + WORD $0x9e670221 // fmov d1, x17 + WORD $0x1e612000 // fcmp d0, d1 + WORD $0xd2a4c691 // mov x17, #640942080 + WORD $0xf2cd7eb1 // movk x17, #27637, lsl #32 + WORD $0xf2f86191 // movk x17, #49932, lsl #48 + WORD $0x9e670221 // fmov d1, x17 + WORD $0x1e61d408 // fccmp d0, d1, #8, le + WORD $0x54000224 // b.mi LBB0_220 $68(%rip) +Lloh18: + WORD $0x1000cf68 // adr x8, _P10_TAB $6636(%rip) +Lloh19: + WORD $0x91000108 // add x8, x8, _P10_TAB@PAGEOFF $0(%rip) + WORD $0xfc6d5901 // ldr d1, [x8, w13, uxtw #3] + WORD $0x1e610800 // fmul d0, d0, d1 + WORD $0x140001ba // b LBB0_310 $1768(%rip) +LBB0_217: + WORD $0x310058bf // cmn w5, #22 + WORD $0x540000e3 // b.lo LBB0_219 $28(%rip) + WORD $0x4b0503e8 // neg w8, w5 +Lloh20: + WORD $0x1000ce69 // adr x9, _P10_TAB $6604(%rip) +Lloh21: + WORD $0x91000129 // add x9, x9, _P10_TAB@PAGEOFF $0(%rip) + WORD $0xfc685921 // ldr d1, [x9, w8, uxtw #3] + WORD $0x1e611800 // fdiv d0, d0, d1 + WORD $0x140001b2 // b LBB0_310 $1736(%rip) +LBB0_219: + WORD $0x510570ad // sub w13, w5, #348 + WORD $0x310ae1bf // cmn w13, #696 + WORD $0x54000663 // b.lo LBB0_224 $204(%rip) +LBB0_220: + WORD $0xdac01184 // clz x4, x12 + WORD $0x9ac42193 // lsl x19, x12, x4 + WORD $0x110570b1 // add w17, w5, #348 +Lloh22: + WORD $0x1000d2c1 // adr x1, _POW10_M128_TAB $6744(%rip) +Lloh23: + WORD $0x91000021 // add x1, x1, _POW10_M128_TAB@PAGEOFF $0(%rip) + WORD $0x8b31502d // add x13, x1, w17, uxtw #4 + WORD $0xf94005a2 // ldr x2, [x13, #8] + WORD $0x9b137c4d // mul x13, x2, x19 + WORD $0x9bd37c46 // umulh x6, x2, x19 + WORD $0x924020c7 // and x7, x6, #0x1ff + WORD $0xaa3303f4 // mvn x20, x19 + WORD $0xf107fcff // cmp x7, #511 + WORD $0xfa5401a0 // ccmp x13, x20, #0, eq + WORD $0x54000189 // b.ls LBB0_222 $48(%rip) + WORD $0xd37cee27 // lsl x7, x17, #4 + WORD $0xf8676827 // ldr x7, [x1, x7] + WORD $0x9b137cf5 // mul x21, x7, x19 + WORD $0x9bd37ce7 // umulh x7, x7, x19 + WORD $0xab0d00ed // adds x13, x7, x13 + WORD $0x9a8634c6 // cinc x6, x6, hs + WORD $0x924020c7 // and x7, x6, #0x1ff + WORD $0xf107fcff // cmp x7, #511 + WORD $0xba4109a0 // ccmn x13, #1, #0, eq + WORD $0xfa5402a0 // ccmp x21, x20, #0, eq + WORD $0x54000348 // b.hi LBB0_224 $104(%rip) +LBB0_222: + WORD $0xd37ffcd3 // lsr x19, x6, #63 + WORD $0x91002674 // add x20, x19, #9 + WORD $0x9ad424c6 // lsr x6, x6, x20 + WORD $0x924004d4 // and x20, x6, #0x3 + WORD $0xf10001bf // cmp x13, #0 + WORD $0xfa4008e0 // ccmp x7, #0, #0, eq + WORD $0xfa410a80 // ccmp x20, #1, #0, eq + WORD $0x54000240 // b.eq LBB0_224 $72(%rip) + WORD $0x528a4d4d // mov w13, #21098 + WORD $0x72a0006d // movk w13, #3, lsl #16 + WORD $0x1b0d7cad // mul w13, w5, w13 + WORD $0x13107dad // asr w13, w13, #16 + WORD $0x1110fdad // add w13, w13, #1087 + WORD $0x93407dad // sxtw x13, w13 + WORD $0x924000c5 // and x5, x6, #0x1 + WORD $0x8b0600a5 // add x5, x5, x6 + WORD $0xd376fca6 // lsr x6, x5, #54 + WORD $0xf10000df // cmp x6, #0 + WORD $0x1a9f17e7 // cset w7, eq + WORD $0xcb0401a4 // sub x4, x13, x4 + WORD $0x8b130084 // add x4, x4, x19 + WORD $0xcb070084 // sub x4, x4, x7 + WORD $0xd11ffc87 // sub x7, x4, #2047 + WORD $0xb11ff8ff // cmn x7, #2046 + WORD $0x54000342 // b.hs LBB0_231 $104(%rip) +LBB0_224: + WORD $0xcb0e0010 // sub x16, x0, x14 + WORD $0xb40020ea // cbz x10, LBB0_277 $1052(%rip) + WORD $0x3900013f // strb wzr, [x9] + WORD $0xf100054b // subs x11, x10, #1 + WORD $0x54002080 // b.eq LBB0_277 $1040(%rip) + WORD $0xf100217f // cmp x11, #8 + WORD $0x540001e2 // b.hs LBB0_229 $60(%rip) + WORD $0x5280002c // mov w12, #1 + WORD $0x140000fb // b LBB0_275 $1004(%rip) +LBB0_228: + WORD $0x9e630180 // ucvtf d0, x12 + WORD $0x9b117d88 // mul x8, x12, x17 + WORD $0x92410229 // and x9, x17, #0x8000000000000000 + WORD $0x9e66000a // fmov x10, d0 + WORD $0xaa0a0129 // orr x9, x9, x10 + WORD $0xa900a069 // stp x9, x8, [x3, #8] + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret +LBB0_229: + WORD $0xf100817f // cmp x11, #32 + WORD $0x54000c82 // b.hs LBB0_250 $400(%rip) + WORD $0xd280000d // mov x13, #0 + WORD $0x1400006e // b LBB0_254 $440(%rip) +LBB0_231: + WORD $0xf10000df // cmp x6, #0 + WORD $0x52800026 // mov w6, #1 + WORD $0x9a8604c6 // cinc x6, x6, ne + WORD $0x9ac624a5 // lsr x5, x5, x6 + WORD $0xb34c2c85 // bfi x5, x4, #52, #12 + WORD $0xb24100a4 // orr x4, x5, #0x8000000000000000 + WORD $0x7100b57f // cmp w11, #45 + WORD $0x9a850084 // csel x4, x4, x5, eq + WORD $0x9e670080 // fmov d0, x4 + WORD $0x34002b50 // cbz w16, LBB0_310 $1384(%rip) + WORD $0x91000590 // add x16, x12, #1 + WORD $0xdac0120c // clz x12, x16 + WORD $0x9acc2205 // lsl x5, x16, x12 + WORD $0x9b057c50 // mul x16, x2, x5 + WORD $0x9bc57c42 // umulh x2, x2, x5 + WORD $0x92402044 // and x4, x2, #0x1ff + WORD $0xf107fc9f // cmp x4, #511 + WORD $0x54000221 // b.ne LBB0_237 $68(%rip) + WORD $0xaa2503e6 // mvn x6, x5 + WORD $0xeb06021f // cmp x16, x6 + WORD $0x540001c9 // b.ls LBB0_237 $56(%rip) + WORD $0xd37cee31 // lsl x17, x17, #4 + WORD $0xf8716831 // ldr x17, [x1, x17] + WORD $0x9bc57e21 // umulh x1, x17, x5 + WORD $0xab100030 // adds x16, x1, x16 + WORD $0x9a823442 // cinc x2, x2, hs + WORD $0x92402044 // and x4, x2, #0x1ff + WORD $0xf107fc9f // cmp x4, #511 + WORD $0x540000c1 // b.ne LBB0_237 $24(%rip) + WORD $0xb100061f // cmn x16, #1 + WORD $0x54000081 // b.ne LBB0_237 $16(%rip) + WORD $0x9b057e31 // mul x17, x17, x5 + WORD $0xeb06023f // cmp x17, x6 + WORD $0x54fff8c8 // b.hi LBB0_224 $-232(%rip) +LBB0_237: + WORD $0xd37ffc51 // lsr x17, x2, #63 + WORD $0x91002621 // add x1, x17, #9 + WORD $0x9ac12441 // lsr x1, x2, x1 + WORD $0xb50000b0 // cbnz x16, LBB0_240 $20(%rip) + WORD $0xb5000084 // cbnz x4, LBB0_240 $16(%rip) + WORD $0x92400430 // and x16, x1, #0x3 + WORD $0xf100061f // cmp x16, #1 + WORD $0x54fff7c0 // b.eq LBB0_224 $-264(%rip) +LBB0_240: + WORD $0x92400030 // and x16, x1, #0x1 + WORD $0x8b010210 // add x16, x16, x1 + WORD $0xd376fe01 // lsr x1, x16, #54 + WORD $0xf100003f // cmp x1, #0 + WORD $0x1a9f17e2 // cset w2, eq + WORD $0xcb0c01ac // sub x12, x13, x12 + WORD $0x8b11018c // add x12, x12, x17 + WORD $0xcb02018c // sub x12, x12, x2 + WORD $0xd11ffd8d // sub x13, x12, #2047 + WORD $0xb11ff9bf // cmn x13, #2046 + WORD $0x54fff663 // b.lo LBB0_224 $-308(%rip) + WORD $0xf100003f // cmp x1, #0 + WORD $0x5280002d // mov w13, #1 + WORD $0x9a8d05ad // cinc x13, x13, ne + WORD $0x9acd260d // lsr x13, x16, x13 + WORD $0xb34c2d8d // bfi x13, x12, #52, #12 + WORD $0xb24101ac // orr x12, x13, #0x8000000000000000 + WORD $0x7100b57f // cmp w11, #45 + WORD $0x9a8d018b // csel x11, x12, x13, eq + WORD $0x9e670161 // fmov d1, x11 + WORD $0x1e612000 // fcmp d0, d1 + WORD $0x54002480 // b.eq LBB0_310 $1168(%rip) + WORD $0x17ffffa7 // b LBB0_224 $-356(%rip) +LBB0_242: + WORD $0x52800022 // mov w2, #1 +LBB0_243: + WORD $0x5100e885 // sub w5, w4, #58 + WORD $0x310028bf // cmn w5, #10 + WORD $0x54000122 // b.hs LBB0_245 $36(%rip) + WORD $0x92800028 // mov x8, #-2 + WORD $0xf9000068 // str x8, [x3] + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret +LBB0_245: + WORD $0xeb01001f // cmp x0, x1 + WORD $0x54000682 // b.hs LBB0_260 $208(%rip) + WORD $0x52800005 // mov w5, #0 + WORD $0x91000506 // add x6, x8, #1 + WORD $0xd1000427 // sub x7, x1, #1 + WORD $0x52800153 // mov w19, #10 + WORD $0x5284e214 // mov w20, #10000 +LBB0_247: + WORD $0x1b1310a4 // madd w4, w5, w19, w4 + WORD $0x5100c084 // sub w4, w4, #48 + WORD $0x6b1400bf // cmp w5, w20 + WORD $0x1a85b085 // csel w5, w4, w5, lt + WORD $0xeb0000ff // cmp x7, x0 + WORD $0x540011a0 // b.eq LBB0_273 $564(%rip) + WORD $0x386068c4 // ldrb w4, [x6, x0] + WORD $0x5100c095 // sub w21, w4, #48 + WORD $0x91000400 // add x0, x0, #1 + WORD $0x71002abf // cmp w21, #10 + WORD $0x54fffec3 // b.lo LBB0_247 $-40(%rip) + WORD $0x1b0244a5 // madd w5, w5, w2, w17 + WORD $0x17ffff25 // b LBB0_209 $-876(%rip) +LBB0_250: + WORD $0x927be96d // and x13, x11, #0xffffffffffffffe0 + WORD $0x9100452c // add x12, x9, #17 + WORD $0x6f00e400 // movi.2d v0, #0000000000000000 + WORD $0xaa0d03f1 // mov x17, x13 +LBB0_251: + WORD $0xad3f8180 // stp q0, q0, [x12, #-16] + WORD $0x9100818c // add x12, x12, #32 + WORD $0xf1008231 // subs x17, x17, #32 + WORD $0x54ffffa1 // b.ne LBB0_251 $-12(%rip) + WORD $0xeb0d017f // cmp x11, x13 + WORD $0x540010a0 // b.eq LBB0_277 $532(%rip) + WORD $0xf27d057f // tst x11, #0x18 + WORD $0x54000fa0 // b.eq LBB0_274 $500(%rip) +LBB0_254: + WORD $0x927df171 // and x17, x11, #0xfffffffffffffff8 + WORD $0xb240022c // orr x12, x17, #0x1 + WORD $0x8b0901a1 // add x1, x13, x9 + WORD $0x91000421 // add x1, x1, #1 + WORD $0xcb1101ad // sub x13, x13, x17 + WORD $0x6f00e400 // movi.2d v0, #0000000000000000 +LBB0_255: + WORD $0xfc008420 // str d0, [x1], #8 + WORD $0xb10021ad // adds x13, x13, #8 + WORD $0x54ffffc1 // b.ne LBB0_255 $-8(%rip) + WORD $0xeb11017f // cmp x11, x17 + WORD $0x54000e61 // b.ne LBB0_275 $460(%rip) + WORD $0x14000077 // b LBB0_277 $476(%rip) +LBB0_257: + WORD $0xaa3103ea // mvn x10, x17 + WORD $0xcb254151 // sub x17, x10, w5, uxtw + WORD $0x17fffee5 // b LBB0_197 $-1132(%rip) +LBB0_258: + WORD $0xaa3103ea // mvn x10, x17 + WORD $0xcb244151 // sub x17, x10, w4, uxtw + WORD $0x17fffee2 // b LBB0_197 $-1144(%rip) +LBB0_259: + WORD $0xaa3103ea // mvn x10, x17 + WORD $0xcb224151 // sub x17, x10, w2, uxtw + WORD $0x17fffedf // b LBB0_197 $-1156(%rip) +LBB0_260: + WORD $0x52800005 // mov w5, #0 + WORD $0x1b0247e5 // madd w5, wzr, w2, w17 + WORD $0x17ffff01 // b LBB0_209 $-1020(%rip) +LBB0_261: + WORD $0x8b0d010d // add x13, x8, x13 + WORD $0xf100816e // subs x14, x11, #32 + WORD $0x54009b63 // b.lo LBB0_588 $4972(%rip) +LBB0_262: + WORD $0xad4005a0 // ldp q0, q1, [x13] + WORD $0x4f01e442 // movi.16b v2, #34 + WORD $0x6e228c03 // cmeq.16b v3, v0, v2 + WORD $0x6e228c22 // cmeq.16b v2, v1, v2 + WORD $0x4f02e784 // movi.16b v4, #92 + WORD $0x6e248c00 // cmeq.16b v0, v0, v4 + WORD $0x6e248c21 // cmeq.16b v1, v1, v4 +Lloh24: + WORD $0x10ff702b // adr x11, lCPI0_0 $-4604(%rip) +Lloh25: + WORD $0x3dc00164 // ldr q4, [x11, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x4e241c63 // and.16b v3, v3, v4 +Lloh26: + WORD $0x10ff704b // adr x11, lCPI0_1 $-4600(%rip) +Lloh27: + WORD $0x3dc00165 // ldr q5, [x11, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x4e050063 // tbl.16b v3, { v3 }, v5 + WORD $0x4e71b863 // addv.8h h3, v3 + WORD $0x1e26006b // fmov w11, s3 + WORD $0x4e241c42 // and.16b v2, v2, v4 + WORD $0x4e050042 // tbl.16b v2, { v2 }, v5 + WORD $0x4e71b842 // addv.8h h2, v2 + WORD $0x1e260050 // fmov w16, s2 + WORD $0x4e241c00 // and.16b v0, v0, v4 + WORD $0x4e050000 // tbl.16b v0, { v0 }, v5 + WORD $0x4e71b800 // addv.8h h0, v0 + WORD $0x1e26000f // fmov w15, s0 + WORD $0x4e241c20 // and.16b v0, v1, v4 + WORD $0x4e050000 // tbl.16b v0, { v0 }, v5 + WORD $0x4e71b800 // addv.8h h0, v0 + WORD $0x1e260011 // fmov w17, s0 + WORD $0x33103e0b // bfi w11, w16, #16, #16 + WORD $0x33103e2f // bfi w15, w17, #16, #16 + WORD $0x350094cf // cbnz w15, LBB0_585 $4760(%rip) + WORD $0xb500958c // cbnz x12, LBB0_586 $4784(%rip) + WORD $0xb400972b // cbz x11, LBB0_587 $4836(%rip) +LBB0_265: + WORD $0xdac0016a // rbit x10, x11 + WORD $0xdac0114a // clz x10, x10 + WORD $0xcb0801a8 // sub x8, x13, x8 + WORD $0x14000037 // b LBB0_272 $220(%rip) +LBB0_266: + WORD $0x8b0c010c // add x12, x8, x12 + WORD $0xf100816d // subs x13, x11, #32 + WORD $0x54009e43 // b.lo LBB0_605 $5064(%rip) +LBB0_267: + WORD $0xad400580 // ldp q0, q1, [x12] + WORD $0x4f01e442 // movi.16b v2, #34 + WORD $0x6e228c03 // cmeq.16b v3, v0, v2 +Lloh28: + WORD $0x10ff6bcb // adr x11, lCPI0_0 $-4744(%rip) +Lloh29: + WORD $0x3dc00164 // ldr q4, [x11, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x4e241c63 // and.16b v3, v3, v4 +Lloh30: + WORD $0x10ff6beb // adr x11, lCPI0_1 $-4740(%rip) +Lloh31: + WORD $0x3dc00165 // ldr q5, [x11, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x4e050063 // tbl.16b v3, { v3 }, v5 + WORD $0x4e71b863 // addv.8h h3, v3 + WORD $0x1e26006b // fmov w11, s3 + WORD $0x6e228c22 // cmeq.16b v2, v1, v2 + WORD $0x4e241c42 // and.16b v2, v2, v4 + WORD $0x4e050042 // tbl.16b v2, { v2 }, v5 + WORD $0x4e71b842 // addv.8h h2, v2 + WORD $0x1e260050 // fmov w16, s2 + WORD $0x4f02e782 // movi.16b v2, #92 + WORD $0x6e228c03 // cmeq.16b v3, v0, v2 + WORD $0x4e241c63 // and.16b v3, v3, v4 + WORD $0x4e050063 // tbl.16b v3, { v3 }, v5 + WORD $0x4e71b863 // addv.8h h3, v3 + WORD $0x1e26006f // fmov w15, s3 + WORD $0x6e228c22 // cmeq.16b v2, v1, v2 + WORD $0x4e241c42 // and.16b v2, v2, v4 + WORD $0x4e050042 // tbl.16b v2, { v2 }, v5 + WORD $0x4e71b842 // addv.8h h2, v2 + WORD $0x1e260051 // fmov w17, s2 + WORD $0x4f01e402 // movi.16b v2, #32 + WORD $0x6e203440 // cmhi.16b v0, v2, v0 + WORD $0x4e241c00 // and.16b v0, v0, v4 + WORD $0x4e050000 // tbl.16b v0, { v0 }, v5 + WORD $0x4e71b800 // addv.8h h0, v0 + WORD $0x1e26000e // fmov w14, s0 + WORD $0x6e213440 // cmhi.16b v0, v2, v1 + WORD $0x4e241c00 // and.16b v0, v0, v4 + WORD $0x4e050000 // tbl.16b v0, { v0 }, v5 + WORD $0x4e71b800 // addv.8h h0, v0 + WORD $0x1e260000 // fmov w0, s0 + WORD $0x33103e0b // bfi w11, w16, #16, #16 + WORD $0x33103e2f // bfi w15, w17, #16, #16 + WORD $0x33103c0e // bfi w14, w0, #16, #16 + WORD $0x3500962f // cbnz w15, LBB0_601 $4804(%rip) + WORD $0xb50096ca // cbnz x10, LBB0_602 $4824(%rip) + WORD $0xb400986b // cbz x11, LBB0_603 $4876(%rip) +LBB0_270: + WORD $0xdac0016a // rbit x10, x11 + WORD $0xdac0114a // clz x10, x10 + WORD $0xdac001cb // rbit x11, x14 + WORD $0xdac0116b // clz x11, x11 + WORD $0xeb0a017f // cmp x11, x10 + WORD $0x54009ba3 // b.lo LBB0_614 $4980(%rip) + WORD $0xcb080188 // sub x8, x12, x8 +LBB0_272: + WORD $0x8b0a0108 // add x8, x8, x10 + WORD $0x91000500 // add x0, x8, #1 + WORD $0xb6ffb800 // tbz x0, #63, LBB0_136 $-2304(%rip) + WORD $0x140004d9 // b LBB0_615 $4964(%rip) +LBB0_273: + WORD $0xaa0103e0 // mov x0, x1 + WORD $0x1b0244a5 // madd w5, w5, w2, w17 + WORD $0x17fffe9d // b LBB0_209 $-1420(%rip) +LBB0_274: + WORD $0xb24001ac // orr x12, x13, #0x1 +LBB0_275: + WORD $0xcb0c014b // sub x11, x10, x12 + WORD $0x8b0c012c // add x12, x9, x12 +LBB0_276: + WORD $0x3800159f // strb wzr, [x12], #1 + WORD $0xf100056b // subs x11, x11, #1 + WORD $0x54ffffc1 // b.ne LBB0_276 $-8(%rip) +LBB0_277: + WORD $0x394001eb // ldrb w11, [x15] + WORD $0x7100b57f // cmp w11, #45 + WORD $0x1a9f17f1 // cset w17, eq + WORD $0xeb11021f // cmp x16, x17 + WORD $0x54000d0d // b.le LBB0_308 $416(%rip) + WORD $0x5280000d // mov w13, #0 + WORD $0x52800006 // mov w6, #0 + WORD $0x5280000c // mov w12, #0 + WORD $0x52800002 // mov w2, #0 + WORD $0x52800004 // mov w4, #0 + WORD $0x52800005 // mov w5, #0 + WORD $0x52800007 // mov w7, #0 + WORD $0x52800001 // mov w1, #0 + WORD $0x52800033 // mov w19, #1 + WORD $0x1400000c // b LBB0_281 $48(%rip) +LBB0_279: + WORD $0x38276934 // strb w20, [x9, x7] + WORD $0x110004c6 // add w6, w6, #1 + WORD $0xaa0603e2 // mov x2, x6 + WORD $0xaa0603e4 // mov x4, x6 + WORD $0xaa0603e5 // mov x5, x6 + WORD $0xaa0603e7 // mov x7, x6 +LBB0_280: + WORD $0x91000631 // add x17, x17, #1 + WORD $0xeb10023f // cmp x17, x16 + WORD $0x1a9fa7f3 // cset w19, lt + WORD $0xeb11021f // cmp x16, x17 + WORD $0x540003c0 // b.eq LBB0_291 $120(%rip) +LBB0_281: + WORD $0x387169f4 // ldrb w20, [x15, x17] + WORD $0x5100c295 // sub w21, w20, #48 + WORD $0x710026bf // cmp w21, #9 + WORD $0x54000168 // b.hi LBB0_286 $44(%rip) + WORD $0x7100c29f // cmp w20, #48 + WORD $0x540001c1 // b.ne LBB0_288 $56(%rip) + WORD $0x34000264 // cbz w4, LBB0_290 $76(%rip) + WORD $0x93407c47 // sxtw x7, w2 + WORD $0xeb07015f // cmp x10, x7 + WORD $0x54fffd88 // b.hi LBB0_279 $-80(%rip) + WORD $0xaa0203e4 // mov x4, x2 + WORD $0xaa0203e5 // mov x5, x2 + WORD $0xaa0203e7 // mov x7, x2 + WORD $0x17ffffee // b LBB0_280 $-72(%rip) +LBB0_286: + WORD $0x7100ba9f // cmp w20, #46 + WORD $0x540001e1 // b.ne LBB0_292 $60(%rip) + WORD $0x52800021 // mov w1, #1 + WORD $0xaa0703ed // mov x13, x7 + WORD $0x17ffffe9 // b LBB0_280 $-92(%rip) +LBB0_288: + WORD $0x93407ca7 // sxtw x7, w5 + WORD $0xeb07015f // cmp x10, x7 + WORD $0x54fffc08 // b.hi LBB0_279 $-128(%rip) + WORD $0x5280002c // mov w12, #1 + WORD $0xaa0503e7 // mov x7, x5 + WORD $0x17ffffe3 // b LBB0_280 $-116(%rip) +LBB0_290: + WORD $0x52800005 // mov w5, #0 + WORD $0x52800007 // mov w7, #0 + WORD $0x510005ad // sub w13, w13, #1 + WORD $0x17ffffdf // b LBB0_280 $-132(%rip) +LBB0_291: + WORD $0xaa1003f1 // mov x17, x16 +LBB0_292: + WORD $0x7100003f // cmp w1, #0 + WORD $0x1a8d004d // csel w13, w2, w13, eq + WORD $0x36000553 // tbz w19, #0, LBB0_304 $168(%rip) + WORD $0x387149e1 // ldrb w1, [x15, w17, uxtw] + WORD $0x321b0021 // orr w1, w1, #0x20 + WORD $0x7101943f // cmp w1, #101 + WORD $0x540004c1 // b.ne LBB0_304 $152(%rip) + WORD $0x2a1103e1 // mov w1, w17 + WORD $0x91000421 // add x1, x1, #1 + WORD $0x386169ef // ldrb w15, [x15, x1] + WORD $0x7100b5ff // cmp w15, #45 + WORD $0x54000100 // b.eq LBB0_296 $32(%rip) + WORD $0x52800022 // mov w2, #1 + WORD $0x11000a31 // add w17, w17, #2 + WORD $0x52800024 // mov w4, #1 + WORD $0x7100adff // cmp w15, #43 + WORD $0x1a911031 // csel w17, w1, w17, ne + WORD $0x1a84104f // csel w15, w2, w4, ne + WORD $0x14000003 // b LBB0_297 $12(%rip) +LBB0_296: + WORD $0x11000a31 // add w17, w17, #2 + WORD $0x1280000f // mov w15, #-1 +LBB0_297: + WORD $0x93407e31 // sxtw x17, w17 + WORD $0xeb11021f // cmp x16, x17 + WORD $0x5400026d // b.le LBB0_302 $76(%rip) + WORD $0x52800010 // mov w16, #0 + WORD $0x8b1101d1 // add x17, x14, x17 + WORD $0xcb00022e // sub x14, x17, x0 + WORD $0x8b110108 // add x8, x8, x17 + WORD $0x5284e1f1 // mov w17, #9999 + WORD $0x52800141 // mov w1, #10 +LBB0_299: + WORD $0x39c00102 // ldrsb w2, [x8] + WORD $0x7100c05f // cmp w2, #48 + WORD $0x5400016b // b.lt LBB0_303 $44(%rip) + WORD $0x7100e45f // cmp w2, #57 + WORD $0x7a519200 // ccmp w16, w17, #0, ls + WORD $0x5400010c // b.gt LBB0_303 $32(%rip) + WORD $0x1b010a10 // madd w16, w16, w1, w2 + WORD $0x5100c210 // sub w16, w16, #48 + WORD $0x91000508 // add x8, x8, #1 + WORD $0xb10005ce // adds x14, x14, #1 + WORD $0x54fffec3 // b.lo LBB0_299 $-40(%rip) + WORD $0x14000002 // b LBB0_303 $8(%rip) +LBB0_302: + WORD $0x52800010 // mov w16, #0 +LBB0_303: + WORD $0x1b0f360d // madd w13, w16, w15, w13 +LBB0_304: + WORD $0x34000106 // cbz w6, LBB0_308 $32(%rip) + WORD $0x7104d9bf // cmp w13, #310 + WORD $0x5400008d // b.le LBB0_307 $16(%rip) +LBB0_306: + WORD $0xd2800009 // mov x9, #0 + WORD $0xd2effe08 // mov x8, #9218868437227405312 + WORD $0x14000005 // b LBB0_309 $20(%rip) +LBB0_307: + WORD $0x310529bf // cmn w13, #330 + WORD $0x540002ea // b.ge LBB0_313 $92(%rip) +LBB0_308: + WORD $0xd2800008 // mov x8, #0 + WORD $0xd2800009 // mov x9, #0 +LBB0_309: + WORD $0x9240cd29 // and x9, x9, #0xfffffffffffff + WORD $0xaa080128 // orr x8, x9, x8 + WORD $0xb2410109 // orr x9, x8, #0x8000000000000000 + WORD $0x7100b57f // cmp w11, #45 + WORD $0x9a880128 // csel x8, x9, x8, eq + WORD $0x9e670100 // fmov d0, x8 +LBB0_310: + WORD $0x9e660008 // fmov x8, d0 + WORD $0x9240f908 // and x8, x8, #0x7fffffffffffffff + WORD $0xd2effe09 // mov x9, #9218868437227405312 + WORD $0xeb09011f // cmp x8, x9 + WORD $0x54000061 // b.ne LBB0_312 $12(%rip) + WORD $0x928000e8 // mov x8, #-8 + WORD $0xf9000068 // str x8, [x3] +LBB0_312: + WORD $0xfd000460 // str d0, [x3, #8] + WORD $0xa9454ff4 // ldp x20, x19, [sp, #80] + WORD $0xa94457f6 // ldp x22, x21, [sp, #64] + WORD $0xa9435ff8 // ldp x24, x23, [sp, #48] + WORD $0xa94267fa // ldp x26, x25, [sp, #32] + WORD $0x910183ff // add sp, sp, #96 + WORD $0xd65f03c0 // ret +LBB0_313: +Lloh32: + WORD $0x1001f82e // adr x14, _POW_TAB $16132(%rip) +Lloh33: + WORD $0x910001ce // add x14, x14, _POW_TAB@PAGEOFF $0(%rip) + WORD $0x710005bf // cmp w13, #1 + WORD $0x54001a4b // b.lt LBB0_372 $840(%rip) + WORD $0x52800008 // mov w8, #0 + WORD $0x9280000f // mov x15, #-1 + WORD $0x52800150 // mov w16, #10 + WORD $0xaa0603f3 // mov x19, x6 + WORD $0xaa0603e1 // mov x1, x6 + WORD $0x14000007 // b LBB0_318 $28(%rip) +LBB0_315: + WORD $0x34007713 // cbz w19, LBB0_580 $3808(%rip) +LBB0_316: + WORD $0xaa1303e6 // mov x6, x19 + WORD $0xaa1303e1 // mov x1, x19 +LBB0_317: + WORD $0x0b080228 // add w8, w17, w8 + WORD $0x710001bf // cmp w13, #0 + WORD $0x5400190d // b.le LBB0_374 $800(%rip) +LBB0_318: + WORD $0x710021bf // cmp w13, #8 + WORD $0x540000a9 // b.ls LBB0_321 $20(%rip) + WORD $0x52800371 // mov w17, #27 + WORD $0x34ffff41 // cbz w1, LBB0_317 $-24(%rip) + WORD $0x12800345 // mov w5, #-27 + WORD $0x1400005e // b LBB0_347 $376(%rip) +LBB0_321: + WORD $0xb86d59d1 // ldr w17, [x14, w13, uxtw #2] + WORD $0x34fffec1 // cbz w1, LBB0_317 $-40(%rip) + WORD $0x4b1103e5 // neg w5, w17 + WORD $0x3100f4bf // cmn w5, #61 + WORD $0x54000109 // b.ls LBB0_326 $32(%rip) + WORD $0x14000058 // b LBB0_347 $352(%rip) +LBB0_323: + WORD $0x5280000d // mov w13, #0 +LBB0_324: + WORD $0x52800006 // mov w6, #0 +LBB0_325: + WORD $0x1100f045 // add w5, w2, #60 + WORD $0xaa0603e1 // mov x1, x6 + WORD $0x3101e05f // cmn w2, #120 + WORD $0x54000a2a // b.ge LBB0_346 $324(%rip) +LBB0_326: + WORD $0xd2800007 // mov x7, #0 + WORD $0xd2800004 // mov x4, #0 + WORD $0xaa0503e2 // mov x2, x5 + WORD $0x7100003f // cmp w1, #0 + WORD $0x1a9fc025 // csel w5, w1, wzr, gt +LBB0_327: + WORD $0xeb0700bf // cmp x5, x7 + WORD $0x54000120 // b.eq LBB0_330 $36(%rip) + WORD $0x38a76933 // ldrsb x19, [x9, x7] + WORD $0x9b104c84 // madd x4, x4, x16, x19 + WORD $0xd100c084 // sub x4, x4, #48 + WORD $0x910004e7 // add x7, x7, #1 + WORD $0xd37cfc93 // lsr x19, x4, #60 + WORD $0xb4ffff33 // cbz x19, LBB0_327 $-28(%rip) + WORD $0xaa0703e5 // mov x5, x7 + WORD $0x14000007 // b LBB0_332 $28(%rip) +LBB0_330: + WORD $0xb4fffd84 // cbz x4, LBB0_324 $-80(%rip) +LBB0_331: + WORD $0x8b040887 // add x7, x4, x4, lsl #2 + WORD $0xd37ff8e4 // lsl x4, x7, #1 + WORD $0x110004a5 // add w5, w5, #1 + WORD $0xd37bf8e7 // ubfx x7, x7, #59, #4 + WORD $0xb4ffff87 // cbz x7, LBB0_331 $-16(%rip) +LBB0_332: + WORD $0x4b0501ad // sub w13, w13, w5 + WORD $0x6b0100bf // cmp w5, w1 + WORD $0x5400026a // b.ge LBB0_336 $76(%rip) + WORD $0xd2800001 // mov x1, #0 + WORD $0x93407ca5 // sxtw x5, w5 + WORD $0x93407cc6 // sxtw x6, w6 + WORD $0x8b050127 // add x7, x9, x5 +LBB0_334: + WORD $0xd37cfc93 // lsr x19, x4, #60 + WORD $0x321c0673 // orr w19, w19, #0x30 + WORD $0x38216933 // strb w19, [x9, x1] + WORD $0x38a168f3 // ldrsb x19, [x7, x1] + WORD $0x9240ec84 // and x4, x4, #0xfffffffffffffff + WORD $0x91000421 // add x1, x1, #1 + WORD $0x9b104c84 // madd x4, x4, x16, x19 + WORD $0xd100c084 // sub x4, x4, #48 + WORD $0x8b0100b3 // add x19, x5, x1 + WORD $0xeb06027f // cmp x19, x6 + WORD $0x54fffecb // b.lt LBB0_334 $-40(%rip) + WORD $0xaa0103e6 // mov x6, x1 + WORD $0xb5000164 // cbnz x4, LBB0_338 $44(%rip) + WORD $0x14000015 // b LBB0_340 $84(%rip) +LBB0_336: + WORD $0x52800006 // mov w6, #0 + WORD $0x14000008 // b LBB0_338 $32(%rip) +LBB0_337: + WORD $0xd37cfc81 // lsr x1, x4, #60 + WORD $0xf100003f // cmp x1, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x9240ec81 // and x1, x4, #0xfffffffffffffff + WORD $0x8b010824 // add x4, x1, x1, lsl #2 + WORD $0xd37ff884 // lsl x4, x4, #1 + WORD $0xb4000181 // cbz x1, LBB0_340 $48(%rip) +LBB0_338: + WORD $0x93407cc1 // sxtw x1, w6 + WORD $0xeb01015f // cmp x10, x1 + WORD $0x54fffee9 // b.ls LBB0_337 $-36(%rip) + WORD $0xd37cfc85 // lsr x5, x4, #60 + WORD $0x321c04a5 // orr w5, w5, #0x30 + WORD $0x38216925 // strb w5, [x9, x1] + WORD $0x110004c6 // add w6, w6, #1 + WORD $0x9240ec81 // and x1, x4, #0xfffffffffffffff + WORD $0x8b010824 // add x4, x1, x1, lsl #2 + WORD $0xd37ff884 // lsl x4, x4, #1 + WORD $0xb5fffec1 // cbnz x1, LBB0_338 $-40(%rip) +LBB0_340: + WORD $0x110005ad // add w13, w13, #1 + WORD $0x710004df // cmp w6, #1 + WORD $0x540001cb // b.lt LBB0_345 $56(%rip) + WORD $0x2a0603e1 // mov w1, w6 + WORD $0x8b090024 // add x4, x1, x9 + WORD $0x385ff084 // ldurb w4, [x4, #-1] + WORD $0x7100c09f // cmp w4, #48 + WORD $0x54fff6e1 // b.ne LBB0_325 $-292(%rip) +LBB0_342: + WORD $0xf1000426 // subs x6, x1, #1 + WORD $0x54fff669 // b.ls LBB0_323 $-308(%rip) + WORD $0x51000821 // sub w1, w1, #2 + WORD $0x38614924 // ldrb w4, [x9, w1, uxtw] + WORD $0xaa0603e1 // mov x1, x6 + WORD $0x7100c09f // cmp w4, #48 + WORD $0x54ffff40 // b.eq LBB0_342 $-24(%rip) + WORD $0x17ffffaf // b LBB0_325 $-324(%rip) +LBB0_345: + WORD $0x35fff5c6 // cbnz w6, LBB0_325 $-328(%rip) + WORD $0x17ffffab // b LBB0_323 $-340(%rip) +LBB0_346: + WORD $0xaa0603e1 // mov x1, x6 +LBB0_347: + WORD $0xd2800013 // mov x19, #0 + WORD $0xd2800002 // mov x2, #0 + WORD $0x4b0503e4 // neg w4, w5 + WORD $0x7100003f // cmp w1, #0 + WORD $0x1a9fc027 // csel w7, w1, wzr, gt +LBB0_348: + WORD $0xeb1300ff // cmp x7, x19 + WORD $0x540003c0 // b.eq LBB0_355 $120(%rip) + WORD $0x38b36925 // ldrsb x5, [x9, x19] + WORD $0x9b101442 // madd x2, x2, x16, x5 + WORD $0xd100c042 // sub x2, x2, #48 + WORD $0x91000673 // add x19, x19, #1 + WORD $0x9ac42445 // lsr x5, x2, x4 + WORD $0xb4ffff25 // cbz x5, LBB0_348 $-28(%rip) + WORD $0xaa1303e7 // mov x7, x19 +LBB0_351: + WORD $0x9ac421e5 // lsl x5, x15, x4 + WORD $0xaa2503e5 // mvn x5, x5 + WORD $0x6b0100ff // cmp w7, w1 + WORD $0x5400044a // b.ge LBB0_359 $136(%rip) + WORD $0xd2800014 // mov x20, #0 + WORD $0xaa0703e1 // mov x1, x7 + WORD $0x93407c21 // sxtw x1, w1 + WORD $0x93407cc6 // sxtw x6, w6 + WORD $0x8b010133 // add x19, x9, x1 +LBB0_353: + WORD $0x9ac42455 // lsr x21, x2, x4 + WORD $0x1100c2b5 // add w21, w21, #48 + WORD $0x38346935 // strb w21, [x9, x20] + WORD $0x38b46a75 // ldrsb x21, [x19, x20] + WORD $0x8a050042 // and x2, x2, x5 + WORD $0x91000694 // add x20, x20, #1 + WORD $0x9b105442 // madd x2, x2, x16, x21 + WORD $0xd100c042 // sub x2, x2, #48 + WORD $0x8b140035 // add x21, x1, x20 + WORD $0xeb0602bf // cmp x21, x6 + WORD $0x54fffecb // b.lt LBB0_353 $-40(%rip) + WORD $0xaa1403f3 // mov x19, x20 + WORD $0x14000011 // b LBB0_360 $68(%rip) +LBB0_355: + WORD $0xb40006c2 // cbz x2, LBB0_369 $216(%rip) + WORD $0x9ac42445 // lsr x5, x2, x4 + WORD $0xb40000e5 // cbz x5, LBB0_358 $28(%rip) + WORD $0x52800013 // mov w19, #0 + WORD $0x9ac421e1 // lsl x1, x15, x4 + WORD $0xaa2103e5 // mvn x5, x1 + WORD $0x4b0701ad // sub w13, w13, w7 + WORD $0x110005ad // add w13, w13, #1 + WORD $0x14000012 // b LBB0_362 $72(%rip) +LBB0_358: + WORD $0x8b020842 // add x2, x2, x2, lsl #2 + WORD $0xd37ff842 // lsl x2, x2, #1 + WORD $0x110004e7 // add w7, w7, #1 + WORD $0x9ac42445 // lsr x5, x2, x4 + WORD $0xb4ffff85 // cbz x5, LBB0_358 $-16(%rip) + WORD $0x17ffffdc // b LBB0_351 $-144(%rip) +LBB0_359: + WORD $0x52800013 // mov w19, #0 +LBB0_360: + WORD $0x4b0701ad // sub w13, w13, w7 + WORD $0x110005ad // add w13, w13, #1 + WORD $0xb5000102 // cbnz x2, LBB0_362 $32(%rip) + WORD $0x14000012 // b LBB0_364 $72(%rip) +LBB0_361: + WORD $0xf100003f // cmp x1, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x8a050041 // and x1, x2, x5 + WORD $0x8b010821 // add x1, x1, x1, lsl #2 + WORD $0xd37ff822 // lsl x2, x1, #1 + WORD $0xb4000182 // cbz x2, LBB0_364 $48(%rip) +LBB0_362: + WORD $0x9ac42441 // lsr x1, x2, x4 + WORD $0x93407e66 // sxtw x6, w19 + WORD $0xeb06015f // cmp x10, x6 + WORD $0x54fffee9 // b.ls LBB0_361 $-36(%rip) + WORD $0x1100c021 // add w1, w1, #48 + WORD $0x38266921 // strb w1, [x9, x6] + WORD $0x11000673 // add w19, w19, #1 + WORD $0x8a050041 // and x1, x2, x5 + WORD $0x8b010821 // add x1, x1, x1, lsl #2 + WORD $0xd37ff822 // lsl x2, x1, #1 + WORD $0xb5fffec2 // cbnz x2, LBB0_362 $-40(%rip) +LBB0_364: + WORD $0x7100067f // cmp w19, #1 + WORD $0x54ffe9ab // b.lt LBB0_315 $-716(%rip) + WORD $0x2a1303e2 // mov w2, w19 + WORD $0x8b090041 // add x1, x2, x9 + WORD $0x385ff021 // ldurb w1, [x1, #-1] + WORD $0x7100c03f // cmp w1, #48 + WORD $0x54ffe921 // b.ne LBB0_316 $-732(%rip) +LBB0_366: + WORD $0xf1000441 // subs x1, x2, #1 + WORD $0x540001a9 // b.ls LBB0_370 $52(%rip) + WORD $0x51000842 // sub w2, w2, #2 + WORD $0x38624924 // ldrb w4, [x9, w2, uxtw] + WORD $0xaa0103e2 // mov x2, x1 + WORD $0x7100c09f // cmp w4, #48 + WORD $0x54ffff40 // b.eq LBB0_366 $-24(%rip) + WORD $0xaa0103e6 // mov x6, x1 + WORD $0xaa0103f3 // mov x19, x1 + WORD $0x17ffff41 // b LBB0_317 $-764(%rip) +LBB0_369: + WORD $0x52800006 // mov w6, #0 + WORD $0x52800013 // mov w19, #0 + WORD $0x52800001 // mov w1, #0 + WORD $0x17ffff3d // b LBB0_317 $-780(%rip) +LBB0_370: + WORD $0x51000446 // sub w6, w2, #1 +LBB0_371: + WORD $0x5280000d // mov w13, #0 + WORD $0x0b080228 // add w8, w17, w8 + WORD $0x14000002 // b LBB0_373 $8(%rip) +LBB0_372: + WORD $0x52800008 // mov w8, #0 +LBB0_373: + WORD $0xaa0603f3 // mov x19, x6 +LBB0_374: + WORD $0x52800d10 // mov w16, #104 + WORD $0xb202e7f1 // mov x17, #-3689348814741910324 + WORD $0xf29999b1 // movk x17, #52429 + WORD $0x92800121 // mov x1, #-10 + WORD $0xb2607fe2 // mov x2, #-4294967296 + WORD $0x52800144 // mov w4, #10 + WORD $0x92800005 // mov x5, #-1 + WORD $0xaa0603e7 // mov x7, x6 + WORD $0xaa1303f4 // mov x20, x19 +Lloh34: + WORD $0x1001dd4f // adr x15, _LSHIFT_TAB $15272(%rip) +Lloh35: + WORD $0x910001ef // add x15, x15, _LSHIFT_TAB@PAGEOFF $0(%rip) + WORD $0x14000002 // b LBB0_376 $8(%rip) +LBB0_375: + WORD $0x4b060108 // sub w8, w8, w6 +LBB0_376: + WORD $0x37f800cd // tbnz w13, #31, LBB0_379 $24(%rip) + WORD $0x3500282d // cbnz w13, LBB0_466 $1284(%rip) + WORD $0x39c00126 // ldrsb w6, [x9] + WORD $0x7100d4df // cmp w6, #53 + WORD $0x5400010b // b.lt LBB0_382 $32(%rip) + WORD $0x1400013d // b LBB0_466 $1268(%rip) +LBB0_379: + WORD $0x310021bf // cmn w13, #8 + WORD $0x540000a2 // b.hs LBB0_382 $20(%rip) + WORD $0x52800366 // mov w6, #27 + WORD $0x34001ff4 // cbz w20, LBB0_450 $1020(%rip) + WORD $0xaa1403f3 // mov x19, x20 + WORD $0x14000004 // b LBB0_383 $16(%rip) +LBB0_382: + WORD $0x4b0d03e6 // neg w6, w13 + WORD $0xb86659c6 // ldr w6, [x14, w6, uxtw #2] + WORD $0x34fffe33 // cbz w19, LBB0_375 $-60(%rip) +LBB0_383: + WORD $0x2a0603f5 // mov w21, w6 + WORD $0x9bb03cd7 // umaddl x23, w6, w16, x15 + WORD $0xb84046f4 // ldr w20, [x23], #4 + WORD $0x93407e76 // sxtw x22, w19 + WORD $0xaa0903f3 // mov x19, x9 + WORD $0xaa1603f8 // mov x24, x22 +LBB0_384: + WORD $0x394002f9 // ldrb w25, [x23] + WORD $0x340001b9 // cbz w25, LBB0_389 $52(%rip) + WORD $0x3940027a // ldrb w26, [x19] + WORD $0x6b19035f // cmp w26, w25 + WORD $0x54000b01 // b.ne LBB0_405 $352(%rip) + WORD $0x91000673 // add x19, x19, #1 + WORD $0x910006f7 // add x23, x23, #1 + WORD $0xf1000718 // subs x24, x24, #1 + WORD $0x54ffff01 // b.ne LBB0_384 $-32(%rip) + WORD $0x9b103eb3 // madd x19, x21, x16, x15 + WORD $0x8b364273 // add x19, x19, w22, uxtw + WORD $0x39401273 // ldrb w19, [x19, #4] + WORD $0x34000053 // cbz w19, LBB0_389 $8(%rip) +LBB0_388: + WORD $0x51000694 // sub w20, w20, #1 +LBB0_389: + WORD $0x710006df // cmp w22, #1 + WORD $0x5400070b // b.lt LBB0_399 $224(%rip) + WORD $0xd2800013 // mov x19, #0 + WORD $0x0b160297 // add w23, w20, w22 + WORD $0x92407ed8 // and x24, x22, #0xffffffff + WORD $0x93407ef9 // sxtw x25, w23 + WORD $0x93607ef6 // sbfiz x22, x23, #32, #32 + WORD $0xd100073a // sub x26, x25, #1 + WORD $0x91000717 // add x23, x24, #1 + WORD $0x14000008 // b LBB0_392 $32(%rip) +LBB0_391: + WORD $0xf100035f // cmp x26, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x8b0202d6 // add x22, x22, x2 + WORD $0xd100071a // sub x26, x24, #1 + WORD $0xd10006f7 // sub x23, x23, #1 + WORD $0xf10006ff // cmp x23, #1 + WORD $0x54000269 // b.ls LBB0_394 $76(%rip) +LBB0_392: + WORD $0xaa1a03f8 // mov x24, x26 + WORD $0x51000af9 // sub w25, w23, #2 + WORD $0x38b94939 // ldrsb x25, [x9, w25, uxtw] + WORD $0xd100c339 // sub x25, x25, #48 + WORD $0x9ad52339 // lsl x25, x25, x21 + WORD $0x8b130339 // add x25, x25, x19 + WORD $0x9bd17f33 // umulh x19, x25, x17 + WORD $0xd343fe73 // lsr x19, x19, #3 + WORD $0x9b01667a // madd x26, x19, x1, x25 + WORD $0xeb0a031f // cmp x24, x10 + WORD $0x54fffde2 // b.hs LBB0_391 $-68(%rip) + WORD $0x1100c35a // add w26, w26, #48 + WORD $0x3838693a // strb w26, [x9, x24] + WORD $0x8b0202d6 // add x22, x22, x2 + WORD $0xd100071a // sub x26, x24, #1 + WORD $0xd10006f7 // sub x23, x23, #1 + WORD $0xf10006ff // cmp x23, #1 + WORD $0x54fffde8 // b.hi LBB0_392 $-68(%rip) +LBB0_394: + WORD $0xf1002b3f // cmp x25, #10 + WORD $0x540002a3 // b.lo LBB0_399 $84(%rip) + WORD $0x93407f15 // sxtw x21, w24 + WORD $0xd10006b5 // sub x21, x21, #1 + WORD $0x14000007 // b LBB0_397 $28(%rip) +LBB0_396: + WORD $0xf10002ff // cmp x23, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0xd10006b5 // sub x21, x21, #1 + WORD $0xf100267f // cmp x19, #9 + WORD $0xaa1603f3 // mov x19, x22 + WORD $0x54000189 // b.ls LBB0_399 $48(%rip) +LBB0_397: + WORD $0x9bd17e76 // umulh x22, x19, x17 + WORD $0xd343fed6 // lsr x22, x22, #3 + WORD $0x9b014ed7 // madd x23, x22, x1, x19 + WORD $0xeb0a02bf // cmp x21, x10 + WORD $0x54fffec2 // b.hs LBB0_396 $-40(%rip) + WORD $0x1100c2f7 // add w23, w23, #48 + WORD $0x38356937 // strb w23, [x9, x21] + WORD $0xd10006b5 // sub x21, x21, #1 + WORD $0xf100267f // cmp x19, #9 + WORD $0xaa1603f3 // mov x19, x22 + WORD $0x54fffec8 // b.hi LBB0_397 $-40(%rip) +LBB0_399: + WORD $0x0b070287 // add w7, w20, w7 + WORD $0xeb27c15f // cmp x10, w7, sxtw + WORD $0x1a8a80e7 // csel w7, w7, w10, hi + WORD $0x0b0d028d // add w13, w20, w13 + WORD $0x710004ff // cmp w7, #1 + WORD $0x540001cb // b.lt LBB0_404 $56(%rip) + WORD $0x8b0900f3 // add x19, x7, x9 + WORD $0x385ff273 // ldurb w19, [x19, #-1] + WORD $0x7100c27f // cmp w19, #48 + WORD $0x54000241 // b.ne LBB0_408 $72(%rip) +LBB0_401: + WORD $0xf10004f3 // subs x19, x7, #1 + WORD $0x540001c9 // b.ls LBB0_406 $56(%rip) + WORD $0x510008e7 // sub w7, w7, #2 + WORD $0x38674934 // ldrb w20, [x9, w7, uxtw] + WORD $0xaa1303e7 // mov x7, x19 + WORD $0x7100c29f // cmp w20, #48 + WORD $0x54ffff40 // b.eq LBB0_401 $-24(%rip) + WORD $0xaa1303e7 // mov x7, x19 + WORD $0x14000009 // b LBB0_408 $36(%rip) +LBB0_404: + WORD $0x35000107 // cbnz w7, LBB0_408 $32(%rip) + WORD $0x14000006 // b LBB0_407 $24(%rip) +LBB0_405: + WORD $0x13001f53 // sxtb w19, w26 + WORD $0x6b39827f // cmp w19, w25, sxtb + WORD $0x54fff5eb // b.lt LBB0_388 $-324(%rip) + WORD $0x17ffffaf // b LBB0_389 $-324(%rip) +LBB0_406: + WORD $0x510004e7 // sub w7, w7, #1 +LBB0_407: + WORD $0x5280000d // mov w13, #0 +LBB0_408: + WORD $0x37f800a6 // tbnz w6, #31, LBB0_410 $20(%rip) +LBB0_409: + WORD $0xaa0703f4 // mov x20, x7 + WORD $0xaa0703f3 // mov x19, x7 + WORD $0x4b060108 // sub w8, w8, w6 + WORD $0x17ffff85 // b LBB0_376 $-492(%rip) +LBB0_410: + WORD $0x3100f4df // cmn w6, #61 + WORD $0x54000ae8 // b.hi LBB0_437 $348(%rip) + WORD $0xaa0603f3 // mov x19, x6 + WORD $0x14000007 // b LBB0_415 $28(%rip) +LBB0_412: + WORD $0x5280000d // mov w13, #0 +LBB0_413: + WORD $0x52800007 // mov w7, #0 +LBB0_414: + WORD $0x1100f276 // add w22, w19, #60 + WORD $0x3101e27f // cmn w19, #120 + WORD $0xaa1603f3 // mov x19, x22 + WORD $0x54000a0a // b.ge LBB0_438 $320(%rip) +LBB0_415: + WORD $0xd2800016 // mov x22, #0 + WORD $0xd2800014 // mov x20, #0 + WORD $0x710000ff // cmp w7, #0 + WORD $0x1a9fc0f5 // csel w21, w7, wzr, gt +LBB0_416: + WORD $0xeb1602bf // cmp x21, x22 + WORD $0x54000120 // b.eq LBB0_419 $36(%rip) + WORD $0x38b66937 // ldrsb x23, [x9, x22] + WORD $0x9b045e94 // madd x20, x20, x4, x23 + WORD $0xd100c294 // sub x20, x20, #48 + WORD $0x910006d6 // add x22, x22, #1 + WORD $0xd37cfe97 // lsr x23, x20, #60 + WORD $0xb4ffff37 // cbz x23, LBB0_416 $-28(%rip) + WORD $0xaa1603f5 // mov x21, x22 + WORD $0x14000007 // b LBB0_421 $28(%rip) +LBB0_419: + WORD $0xb4fffdb4 // cbz x20, LBB0_413 $-76(%rip) +LBB0_420: + WORD $0x8b140a96 // add x22, x20, x20, lsl #2 + WORD $0xd37ffad4 // lsl x20, x22, #1 + WORD $0x110006b5 // add w21, w21, #1 + WORD $0xd37bfad6 // ubfx x22, x22, #59, #4 + WORD $0xb4ffff96 // cbz x22, LBB0_420 $-16(%rip) +LBB0_421: + WORD $0x4b1501ad // sub w13, w13, w21 + WORD $0x6b0702bf // cmp w21, w7 + WORD $0x5400024a // b.ge LBB0_426 $72(%rip) + WORD $0x93407eb5 // sxtw x21, w21 + WORD $0x93407cf6 // sxtw x22, w7 + WORD $0xcb1502c7 // sub x7, x22, x21 + WORD $0xaa0903f7 // mov x23, x9 +LBB0_423: + WORD $0xd37cfe98 // lsr x24, x20, #60 + WORD $0x321c0718 // orr w24, w24, #0x30 + WORD $0x390002f8 // strb w24, [x23] + WORD $0x38b56af8 // ldrsb x24, [x23, x21] + WORD $0x9240ee94 // and x20, x20, #0xfffffffffffffff + WORD $0x9b046294 // madd x20, x20, x4, x24 + WORD $0xd100c294 // sub x20, x20, #48 + WORD $0x910006f7 // add x23, x23, #1 + WORD $0xd10006d6 // sub x22, x22, #1 + WORD $0xeb1602bf // cmp x21, x22 + WORD $0x54fffec1 // b.ne LBB0_423 $-40(%rip) + WORD $0xb5000074 // cbnz x20, LBB0_427 $12(%rip) + WORD $0x14000015 // b LBB0_431 $84(%rip) +LBB0_426: + WORD $0x52800007 // mov w7, #0 +LBB0_427: + WORD $0x14000008 // b LBB0_429 $32(%rip) +LBB0_428: + WORD $0xd37cfe95 // lsr x21, x20, #60 + WORD $0xf10002bf // cmp x21, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x9240ee95 // and x21, x20, #0xfffffffffffffff + WORD $0x8b150ab4 // add x20, x21, x21, lsl #2 + WORD $0xd37ffa94 // lsl x20, x20, #1 + WORD $0xb4000195 // cbz x21, LBB0_431 $48(%rip) +LBB0_429: + WORD $0x93407cf5 // sxtw x21, w7 + WORD $0xeb15015f // cmp x10, x21 + WORD $0x54fffee9 // b.ls LBB0_428 $-36(%rip) + WORD $0xd37cfe96 // lsr x22, x20, #60 + WORD $0x321c06d6 // orr w22, w22, #0x30 + WORD $0x38356936 // strb w22, [x9, x21] + WORD $0x110004e7 // add w7, w7, #1 + WORD $0x9240ee95 // and x21, x20, #0xfffffffffffffff + WORD $0x8b150ab4 // add x20, x21, x21, lsl #2 + WORD $0xd37ffa94 // lsl x20, x20, #1 + WORD $0xb5fffed5 // cbnz x21, LBB0_429 $-40(%rip) +LBB0_431: + WORD $0x110005ad // add w13, w13, #1 + WORD $0x710004ff // cmp w7, #1 + WORD $0x540001cb // b.lt LBB0_436 $56(%rip) + WORD $0x2a0703f4 // mov w20, w7 + WORD $0x8b090295 // add x21, x20, x9 + WORD $0x385ff2b5 // ldurb w21, [x21, #-1] + WORD $0x7100c2bf // cmp w21, #48 + WORD $0x54fff721 // b.ne LBB0_414 $-284(%rip) +LBB0_433: + WORD $0xf1000687 // subs x7, x20, #1 + WORD $0x54fff6a9 // b.ls LBB0_412 $-300(%rip) + WORD $0x51000a94 // sub w20, w20, #2 + WORD $0x38744935 // ldrb w21, [x9, w20, uxtw] + WORD $0xaa0703f4 // mov x20, x7 + WORD $0x7100c2bf // cmp w21, #48 + WORD $0x54ffff40 // b.eq LBB0_433 $-24(%rip) + WORD $0x17ffffb1 // b LBB0_414 $-316(%rip) +LBB0_436: + WORD $0x35fff607 // cbnz w7, LBB0_414 $-320(%rip) + WORD $0x17ffffad // b LBB0_412 $-332(%rip) +LBB0_437: + WORD $0xaa0603f6 // mov x22, x6 +LBB0_438: + WORD $0xd2800014 // mov x20, #0 + WORD $0xd2800015 // mov x21, #0 + WORD $0x4b1603f3 // neg w19, w22 + WORD $0x710000ff // cmp w7, #0 + WORD $0x1a9fc0f7 // csel w23, w7, wzr, gt +LBB0_439: + WORD $0xeb1402ff // cmp x23, x20 + WORD $0x540003c0 // b.eq LBB0_446 $120(%rip) + WORD $0x38b46936 // ldrsb x22, [x9, x20] + WORD $0x9b045ab5 // madd x21, x21, x4, x22 + WORD $0xd100c2b5 // sub x21, x21, #48 + WORD $0x91000694 // add x20, x20, #1 + WORD $0x9ad326b6 // lsr x22, x21, x19 + WORD $0xb4ffff36 // cbz x22, LBB0_439 $-28(%rip) + WORD $0xaa1403f7 // mov x23, x20 +LBB0_442: + WORD $0x9ad320b4 // lsl x20, x5, x19 + WORD $0xaa3403f6 // mvn x22, x20 + WORD $0x6b0702ff // cmp w23, w7 + WORD $0x540004aa // b.ge LBB0_451 $148(%rip) + WORD $0xaa1703f4 // mov x20, x23 + WORD $0x93407e94 // sxtw x20, w20 + WORD $0x93407cf8 // sxtw x24, w7 + WORD $0xcb140307 // sub x7, x24, x20 + WORD $0xaa0903f9 // mov x25, x9 +LBB0_444: + WORD $0x9ad326ba // lsr x26, x21, x19 + WORD $0x1100c35a // add w26, w26, #48 + WORD $0x3900033a // strb w26, [x25] + WORD $0x38b46b3a // ldrsb x26, [x25, x20] + WORD $0x8a1602b5 // and x21, x21, x22 + WORD $0x9b046ab5 // madd x21, x21, x4, x26 + WORD $0xd100c2b5 // sub x21, x21, #48 + WORD $0x91000739 // add x25, x25, #1 + WORD $0xd1000718 // sub x24, x24, #1 + WORD $0xeb18029f // cmp x20, x24 + WORD $0x54fffec1 // b.ne LBB0_444 $-40(%rip) + WORD $0xaa0703f4 // mov x20, x7 + WORD $0x14000014 // b LBB0_452 $80(%rip) +LBB0_446: + WORD $0xb40007d5 // cbz x21, LBB0_463 $248(%rip) + WORD $0x9ad326b4 // lsr x20, x21, x19 + WORD $0xb40000f4 // cbz x20, LBB0_449 $28(%rip) + WORD $0x52800014 // mov w20, #0 + WORD $0x9ad320a7 // lsl x7, x5, x19 + WORD $0xaa2703f6 // mvn x22, x7 + WORD $0x4b1701ad // sub w13, w13, w23 + WORD $0x110005ad // add w13, w13, #1 + WORD $0x14000015 // b LBB0_454 $84(%rip) +LBB0_449: + WORD $0x8b150ab4 // add x20, x21, x21, lsl #2 + WORD $0xd37ffa95 // lsl x21, x20, #1 + WORD $0x110006f7 // add w23, w23, #1 + WORD $0x9ad326b4 // lsr x20, x21, x19 + WORD $0xb4ffff94 // cbz x20, LBB0_449 $-16(%rip) + WORD $0x17ffffdc // b LBB0_442 $-144(%rip) +LBB0_450: + WORD $0x52800013 // mov w19, #0 + WORD $0x4b060108 // sub w8, w8, w6 + WORD $0x17fffef6 // b LBB0_376 $-1064(%rip) +LBB0_451: + WORD $0x52800014 // mov w20, #0 +LBB0_452: + WORD $0x4b1701ad // sub w13, w13, w23 + WORD $0x110005ad // add w13, w13, #1 + WORD $0xb5000115 // cbnz x21, LBB0_454 $32(%rip) + WORD $0x14000012 // b LBB0_456 $72(%rip) +LBB0_453: + WORD $0xf10000ff // cmp x7, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x8a1602a7 // and x7, x21, x22 + WORD $0x8b0708e7 // add x7, x7, x7, lsl #2 + WORD $0xd37ff8f5 // lsl x21, x7, #1 + WORD $0xb4000195 // cbz x21, LBB0_456 $48(%rip) +LBB0_454: + WORD $0x9ad326a7 // lsr x7, x21, x19 + WORD $0x93407e97 // sxtw x23, w20 + WORD $0xeb17015f // cmp x10, x23 + WORD $0x54fffee9 // b.ls LBB0_453 $-36(%rip) + WORD $0x1100c0e7 // add w7, w7, #48 + WORD $0x38376927 // strb w7, [x9, x23] + WORD $0x11000694 // add w20, w20, #1 + WORD $0x8a1602a7 // and x7, x21, x22 + WORD $0x8b0708e7 // add x7, x7, x7, lsl #2 + WORD $0xd37ff8f5 // lsl x21, x7, #1 + WORD $0xb5fffed5 // cbnz x21, LBB0_454 $-40(%rip) +LBB0_456: + WORD $0x7100069f // cmp w20, #1 + WORD $0x5400020b // b.lt LBB0_461 $64(%rip) + WORD $0x2a1403e7 // mov w7, w20 + WORD $0x8b0900f3 // add x19, x7, x9 + WORD $0x385ff273 // ldurb w19, [x19, #-1] + WORD $0x7100c27f // cmp w19, #48 + WORD $0x54000181 // b.ne LBB0_462 $48(%rip) +LBB0_458: + WORD $0xf10004f3 // subs x19, x7, #1 + WORD $0x54000269 // b.ls LBB0_464 $76(%rip) + WORD $0x510008e7 // sub w7, w7, #2 + WORD $0x38674934 // ldrb w20, [x9, w7, uxtw] + WORD $0xaa1303e7 // mov x7, x19 + WORD $0x7100c29f // cmp w20, #48 + WORD $0x54ffff40 // b.eq LBB0_458 $-24(%rip) + WORD $0xaa1303e7 // mov x7, x19 + WORD $0xaa1303f4 // mov x20, x19 + WORD $0x17fffece // b LBB0_375 $-1224(%rip) +LBB0_461: + WORD $0x340001b4 // cbz w20, LBB0_465 $52(%rip) +LBB0_462: + WORD $0xaa1403e7 // mov x7, x20 + WORD $0xaa1403f3 // mov x19, x20 + WORD $0x4b060108 // sub w8, w8, w6 + WORD $0x17fffeca // b LBB0_376 $-1240(%rip) +LBB0_463: + WORD $0x52800007 // mov w7, #0 + WORD $0x52800014 // mov w20, #0 + WORD $0x52800013 // mov w19, #0 + WORD $0x4b060108 // sub w8, w8, w6 + WORD $0x17fffec5 // b LBB0_376 $-1260(%rip) +LBB0_464: + WORD $0x510004e7 // sub w7, w7, #1 + WORD $0x5280000d // mov w13, #0 + WORD $0x17ffff3a // b LBB0_409 $-792(%rip) +LBB0_465: + WORD $0x52800007 // mov w7, #0 + WORD $0x5280000d // mov w13, #0 + WORD $0x17ffff37 // b LBB0_409 $-804(%rip) +LBB0_466: + WORD $0x310ff91f // cmn w8, #1022 + WORD $0x54000bcc // b.gt LBB0_493 $376(%rip) + WORD $0x34001353 // cbz w19, LBB0_508 $616(%rip) + WORD $0x110ff50e // add w14, w8, #1021 + WORD $0x3110e91f // cmn w8, #1082 + WORD $0x54000bc8 // b.hi LBB0_495 $376(%rip) + WORD $0x52800148 // mov w8, #10 + WORD $0x14000009 // b LBB0_473 $36(%rip) +LBB0_470: + WORD $0x5280000d // mov w13, #0 +LBB0_471: + WORD $0x52800007 // mov w7, #0 +LBB0_472: + WORD $0x1100f1d1 // add w17, w14, #60 + WORD $0xaa0703f3 // mov x19, x7 + WORD $0xaa0703e1 // mov x1, x7 + WORD $0x3101e1df // cmn w14, #120 + WORD $0xaa1103ee // mov x14, x17 + WORD $0x54000aca // b.ge LBB0_496 $344(%rip) +LBB0_473: + WORD $0xd2800001 // mov x1, #0 + WORD $0xd2800010 // mov x16, #0 + WORD $0x7100027f // cmp w19, #0 + WORD $0x1a9fc271 // csel w17, w19, wzr, gt +LBB0_474: + WORD $0xeb01023f // cmp x17, x1 + WORD $0x54000120 // b.eq LBB0_477 $36(%rip) + WORD $0x38a16922 // ldrsb x2, [x9, x1] + WORD $0x9b080a10 // madd x16, x16, x8, x2 + WORD $0xd100c210 // sub x16, x16, #48 + WORD $0x91000421 // add x1, x1, #1 + WORD $0xd37cfe02 // lsr x2, x16, #60 + WORD $0xb4ffff22 // cbz x2, LBB0_474 $-28(%rip) + WORD $0xaa0103f1 // mov x17, x1 + WORD $0x14000007 // b LBB0_479 $28(%rip) +LBB0_477: + WORD $0xb4fffd70 // cbz x16, LBB0_471 $-84(%rip) +LBB0_478: + WORD $0x8b100a01 // add x1, x16, x16, lsl #2 + WORD $0xd37ff830 // lsl x16, x1, #1 + WORD $0x11000631 // add w17, w17, #1 + WORD $0xd37bf821 // ubfx x1, x1, #59, #4 + WORD $0xb4ffff81 // cbz x1, LBB0_478 $-16(%rip) +LBB0_479: + WORD $0x4b1101ad // sub w13, w13, w17 + WORD $0x6b13023f // cmp w17, w19 + WORD $0x5400026a // b.ge LBB0_483 $76(%rip) + WORD $0xd2800001 // mov x1, #0 + WORD $0x93407e31 // sxtw x17, w17 + WORD $0x93407ce2 // sxtw x2, w7 + WORD $0x8b110124 // add x4, x9, x17 +LBB0_481: + WORD $0xd37cfe05 // lsr x5, x16, #60 + WORD $0x321c04a5 // orr w5, w5, #0x30 + WORD $0x38216925 // strb w5, [x9, x1] + WORD $0x38a16885 // ldrsb x5, [x4, x1] + WORD $0x9240ee10 // and x16, x16, #0xfffffffffffffff + WORD $0x91000421 // add x1, x1, #1 + WORD $0x9b081610 // madd x16, x16, x8, x5 + WORD $0xd100c210 // sub x16, x16, #48 + WORD $0x8b010225 // add x5, x17, x1 + WORD $0xeb0200bf // cmp x5, x2 + WORD $0x54fffecb // b.lt LBB0_481 $-40(%rip) + WORD $0xaa0103e7 // mov x7, x1 + WORD $0xb5000170 // cbnz x16, LBB0_485 $44(%rip) + WORD $0x14000015 // b LBB0_487 $84(%rip) +LBB0_483: + WORD $0x52800007 // mov w7, #0 + WORD $0x14000008 // b LBB0_485 $32(%rip) +LBB0_484: + WORD $0xd37cfe11 // lsr x17, x16, #60 + WORD $0xf100023f // cmp x17, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x9240ee11 // and x17, x16, #0xfffffffffffffff + WORD $0x8b110a30 // add x16, x17, x17, lsl #2 + WORD $0xd37ffa10 // lsl x16, x16, #1 + WORD $0xb4000191 // cbz x17, LBB0_487 $48(%rip) +LBB0_485: + WORD $0x93407cf1 // sxtw x17, w7 + WORD $0xeb11015f // cmp x10, x17 + WORD $0x54fffee9 // b.ls LBB0_484 $-36(%rip) + WORD $0xd37cfe01 // lsr x1, x16, #60 + WORD $0x321c0421 // orr w1, w1, #0x30 + WORD $0x38316921 // strb w1, [x9, x17] + WORD $0x110004e7 // add w7, w7, #1 + WORD $0x9240ee11 // and x17, x16, #0xfffffffffffffff + WORD $0x8b110a30 // add x16, x17, x17, lsl #2 + WORD $0xd37ffa10 // lsl x16, x16, #1 + WORD $0xb5fffed1 // cbnz x17, LBB0_485 $-40(%rip) +LBB0_487: + WORD $0x110005ad // add w13, w13, #1 + WORD $0x710004ff // cmp w7, #1 + WORD $0x540001cb // b.lt LBB0_492 $56(%rip) + WORD $0x2a0703f0 // mov w16, w7 + WORD $0x8b090211 // add x17, x16, x9 + WORD $0x385ff231 // ldurb w17, [x17, #-1] + WORD $0x7100c23f // cmp w17, #48 + WORD $0x54fff6c1 // b.ne LBB0_472 $-296(%rip) +LBB0_489: + WORD $0xf1000607 // subs x7, x16, #1 + WORD $0x54fff649 // b.ls LBB0_470 $-312(%rip) + WORD $0x51000a10 // sub w16, w16, #2 + WORD $0x38704931 // ldrb w17, [x9, w16, uxtw] + WORD $0xaa0703f0 // mov x16, x7 + WORD $0x7100c23f // cmp w17, #48 + WORD $0x54ffff40 // b.eq LBB0_489 $-24(%rip) + WORD $0x17ffffae // b LBB0_472 $-328(%rip) +LBB0_492: + WORD $0x35fff5a7 // cbnz w7, LBB0_472 $-332(%rip) + WORD $0x17ffffaa // b LBB0_470 $-344(%rip) +LBB0_493: + WORD $0x7110011f // cmp w8, #1024 + WORD $0x54ffabec // b.gt LBB0_306 $-2692(%rip) + WORD $0x51000508 // sub w8, w8, #1 + WORD $0x14000075 // b LBB0_525 $468(%rip) +LBB0_495: + WORD $0xaa1303e1 // mov x1, x19 + WORD $0xaa0e03f1 // mov x17, x14 +LBB0_496: + WORD $0xd2800010 // mov x16, #0 + WORD $0xd2800008 // mov x8, #0 + WORD $0x4b1103ee // neg w14, w17 + WORD $0x7100003f // cmp w1, #0 + WORD $0x1a9fc031 // csel w17, w1, wzr, gt + WORD $0x52800142 // mov w2, #10 +LBB0_497: + WORD $0xeb10023f // cmp x17, x16 + WORD $0x54000400 // b.eq LBB0_504 $128(%rip) + WORD $0x38b06924 // ldrsb x4, [x9, x16] + WORD $0x9b021108 // madd x8, x8, x2, x4 + WORD $0xd100c108 // sub x8, x8, #48 + WORD $0x91000610 // add x16, x16, #1 + WORD $0x9ace2504 // lsr x4, x8, x14 + WORD $0xb4ffff24 // cbz x4, LBB0_497 $-28(%rip) + WORD $0xaa1003f1 // mov x17, x16 +LBB0_500: + WORD $0x92800010 // mov x16, #-1 + WORD $0x9ace2210 // lsl x16, x16, x14 + WORD $0xaa3003f0 // mvn x16, x16 + WORD $0x6b01023f // cmp w17, w1 + WORD $0x5400052a // b.ge LBB0_510 $164(%rip) + WORD $0xd2800005 // mov x5, #0 + WORD $0xaa1103e1 // mov x1, x17 + WORD $0x93407c21 // sxtw x1, w1 + WORD $0x93407ce2 // sxtw x2, w7 + WORD $0x8b010124 // add x4, x9, x1 + WORD $0x52800146 // mov w6, #10 +LBB0_502: + WORD $0x9ace2507 // lsr x7, x8, x14 + WORD $0x1100c0e7 // add w7, w7, #48 + WORD $0x38256927 // strb w7, [x9, x5] + WORD $0x38a56887 // ldrsb x7, [x4, x5] + WORD $0x8a100108 // and x8, x8, x16 + WORD $0x910004a5 // add x5, x5, #1 + WORD $0x9b061d08 // madd x8, x8, x6, x7 + WORD $0xd100c108 // sub x8, x8, #48 + WORD $0x8b050027 // add x7, x1, x5 + WORD $0xeb0200ff // cmp x7, x2 + WORD $0x54fffecb // b.lt LBB0_502 $-40(%rip) + WORD $0xaa0503e7 // mov x7, x5 + WORD $0x14000017 // b LBB0_511 $92(%rip) +LBB0_504: + WORD $0xb4000208 // cbz x8, LBB0_508 $64(%rip) + WORD $0x9ace2510 // lsr x16, x8, x14 + WORD $0xb4000110 // cbz x16, LBB0_507 $32(%rip) + WORD $0x52800007 // mov w7, #0 + WORD $0x92800010 // mov x16, #-1 + WORD $0x9ace2210 // lsl x16, x16, x14 + WORD $0xaa3003f0 // mvn x16, x16 + WORD $0x4b1101ad // sub w13, w13, w17 + WORD $0x110005ad // add w13, w13, #1 + WORD $0x14000017 // b LBB0_513 $92(%rip) +LBB0_507: + WORD $0x8b080908 // add x8, x8, x8, lsl #2 + WORD $0xd37ff908 // lsl x8, x8, #1 + WORD $0x11000631 // add w17, w17, #1 + WORD $0x9ace2510 // lsr x16, x8, x14 + WORD $0xb4ffff90 // cbz x16, LBB0_507 $-16(%rip) + WORD $0x17ffffd9 // b LBB0_500 $-156(%rip) +LBB0_508: + WORD $0x5280000a // mov w10, #0 + WORD $0x12807fa8 // mov w8, #-1022 + WORD $0x140000a2 // b LBB0_552 $648(%rip) +LBB0_509: + WORD $0x9280000e // mov x14, #-1 + WORD $0x17fffabd // b LBB0_161 $-5388(%rip) +LBB0_510: + WORD $0x52800007 // mov w7, #0 +LBB0_511: + WORD $0x4b1101ad // sub w13, w13, w17 + WORD $0x110005ad // add w13, w13, #1 + WORD $0xb5000108 // cbnz x8, LBB0_513 $32(%rip) + WORD $0x14000012 // b LBB0_515 $72(%rip) +LBB0_512: + WORD $0xf100023f // cmp x17, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x8a100108 // and x8, x8, x16 + WORD $0x8b080908 // add x8, x8, x8, lsl #2 + WORD $0xd37ff908 // lsl x8, x8, #1 + WORD $0xb4000188 // cbz x8, LBB0_515 $48(%rip) +LBB0_513: + WORD $0x9ace2511 // lsr x17, x8, x14 + WORD $0x93407ce1 // sxtw x1, w7 + WORD $0xeb01015f // cmp x10, x1 + WORD $0x54fffee9 // b.ls LBB0_512 $-36(%rip) + WORD $0x1100c231 // add w17, w17, #48 + WORD $0x38216931 // strb w17, [x9, x1] + WORD $0x110004e7 // add w7, w7, #1 + WORD $0x8a100108 // and x8, x8, x16 + WORD $0x8b080908 // add x8, x8, x8, lsl #2 + WORD $0xd37ff908 // lsl x8, x8, #1 + WORD $0xb5fffec8 // cbnz x8, LBB0_513 $-40(%rip) +LBB0_515: + WORD $0x710004ff // cmp w7, #1 + WORD $0x540001cb // b.lt LBB0_519 $56(%rip) + WORD $0x2a0703ee // mov w14, w7 + WORD $0x8b0901c8 // add x8, x14, x9 + WORD $0x385ff108 // ldurb w8, [x8, #-1] + WORD $0x7100c11f // cmp w8, #48 + WORD $0x54000261 // b.ne LBB0_522 $76(%rip) +LBB0_517: + WORD $0xaa0e03e8 // mov x8, x14 + WORD $0xf10005ce // subs x14, x14, #1 + WORD $0x54000269 // b.ls LBB0_523 $76(%rip) + WORD $0x51000910 // sub w16, w8, #2 + WORD $0x38704930 // ldrb w16, [x9, w16, uxtw] + WORD $0x7100c21f // cmp w16, #48 + WORD $0x54ffff40 // b.eq LBB0_517 $-24(%rip) + WORD $0x1400000f // b LBB0_524 $60(%rip) +LBB0_519: + WORD $0x12807fa8 // mov w8, #-1022 + WORD $0x340019e7 // cbz w7, LBB0_578 $828(%rip) + WORD $0xaa0703f3 // mov x19, x7 + WORD $0x1400000f // b LBB0_527 $60(%rip) +LBB0_521: + WORD $0x9280000b // mov x11, #-1 + WORD $0xaa0903e0 // mov x0, x9 + WORD $0xaa0f03ed // mov x13, x15 + WORD $0x9280000c // mov x12, #-1 + WORD $0x9280000a // mov x10, #-1 + WORD $0x17fff8a8 // b LBB0_64 $-7520(%rip) +LBB0_522: + WORD $0x12807fa8 // mov w8, #-1022 + WORD $0xaa0703f3 // mov x19, x7 + WORD $0x14000006 // b LBB0_527 $24(%rip) +LBB0_523: + WORD $0x5280000d // mov w13, #0 +LBB0_524: + WORD $0x51000507 // sub w7, w8, #1 + WORD $0x12807fa8 // mov w8, #-1022 + WORD $0xaa0703f3 // mov x19, x7 +LBB0_525: + WORD $0x34000293 // cbz w19, LBB0_533 $80(%rip) +LBB0_527: + WORD $0xd280000e // mov x14, #0 + WORD $0x93407e70 // sxtw x16, w19 + WORD $0x5282b191 // mov w17, #5516 +LBB0_528: + WORD $0xf10099df // cmp x14, #38 + WORD $0x54000280 // b.eq LBB0_535 $80(%rip) + WORD $0x8b0e01e1 // add x1, x15, x14 + WORD $0x38f16821 // ldrsb w1, [x1, x17] + WORD $0x386e6922 // ldrb w2, [x9, x14] + WORD $0x6b21005f // cmp w2, w1, uxtb + WORD $0x54000181 // b.ne LBB0_534 $48(%rip) + WORD $0x910005ce // add x14, x14, #1 + WORD $0xeb0e021f // cmp x16, x14 + WORD $0x54fffee1 // b.ne LBB0_528 $-36(%rip) + WORD $0x8b3041ee // add x14, x15, w16, uxtw + WORD $0x5282b18f // mov w15, #5516 + WORD $0x386f69ce // ldrb w14, [x14, x15] + WORD $0x3400010e // cbz w14, LBB0_535 $32(%rip) +LBB0_532: + WORD $0x528001ee // mov w14, #15 + WORD $0x14000007 // b LBB0_536 $28(%rip) +LBB0_533: + WORD $0x5280000a // mov w10, #0 + WORD $0x14000054 // b LBB0_552 $336(%rip) +LBB0_534: + WORD $0x13001c4e // sxtb w14, w2 + WORD $0x6b0101df // cmp w14, w1 + WORD $0x54ffff4b // b.lt LBB0_532 $-24(%rip) +LBB0_535: + WORD $0x5280020e // mov w14, #16 +LBB0_536: + WORD $0x7100061f // cmp w16, #1 + WORD $0x5400074b // b.lt LBB0_546 $232(%rip) + WORD $0xd280000f // mov x15, #0 + WORD $0x0b1001d1 // add w17, w14, w16 + WORD $0x92407e10 // and x16, x16, #0xffffffff + WORD $0x93407e31 // sxtw x17, w17 + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0xd2ff4001 // mov x1, #-432345564227567616 + WORD $0xb202e7e2 // mov x2, #-3689348814741910324 + WORD $0xf29999a2 // movk x2, #52429 + WORD $0x92800124 // mov x4, #-10 + WORD $0x14000007 // b LBB0_539 $28(%rip) +LBB0_538: + WORD $0xf10000df // cmp x6, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0x91000606 // add x6, x16, #1 + WORD $0xf10004df // cmp x6, #1 + WORD $0x54000209 // b.ls LBB0_541 $64(%rip) +LBB0_539: + WORD $0xd1000610 // sub x16, x16, #1 + WORD $0x38b04925 // ldrsb x5, [x9, w16, uxtw] + WORD $0x8b05d5ef // add x15, x15, x5, lsl #53 + WORD $0x8b0101e5 // add x5, x15, x1 + WORD $0x9bc27caf // umulh x15, x5, x2 + WORD $0xd343fdef // lsr x15, x15, #3 + WORD $0x9b0415e6 // madd x6, x15, x4, x5 + WORD $0xeb0a023f // cmp x17, x10 + WORD $0x54fffe42 // b.hs LBB0_538 $-56(%rip) + WORD $0x1100c0c6 // add w6, w6, #48 + WORD $0x38316926 // strb w6, [x9, x17] + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0x91000606 // add x6, x16, #1 + WORD $0xf10004df // cmp x6, #1 + WORD $0x54fffe48 // b.hi LBB0_539 $-56(%rip) +LBB0_541: + WORD $0xf10028bf // cmp x5, #10 + WORD $0x54000323 // b.lo LBB0_546 $100(%rip) + WORD $0x8b2e4210 // add x16, x16, w14, uxtw + WORD $0x93407e10 // sxtw x16, w16 + WORD $0xd1000610 // sub x16, x16, #1 + WORD $0xb202e7f1 // mov x17, #-3689348814741910324 + WORD $0xf29999b1 // movk x17, #52429 + WORD $0x92800121 // mov x1, #-10 + WORD $0x14000007 // b LBB0_544 $28(%rip) +LBB0_543: + WORD $0xf100009f // cmp x4, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0xd1000610 // sub x16, x16, #1 + WORD $0xf10025ff // cmp x15, #9 + WORD $0xaa0203ef // mov x15, x2 + WORD $0x54000189 // b.ls LBB0_546 $48(%rip) +LBB0_544: + WORD $0x9bd17de2 // umulh x2, x15, x17 + WORD $0xd343fc42 // lsr x2, x2, #3 + WORD $0x9b013c44 // madd x4, x2, x1, x15 + WORD $0xeb0a021f // cmp x16, x10 + WORD $0x54fffec2 // b.hs LBB0_543 $-40(%rip) + WORD $0x1100c084 // add w4, w4, #48 + WORD $0x38306924 // strb w4, [x9, x16] + WORD $0xd1000610 // sub x16, x16, #1 + WORD $0xf10025ff // cmp x15, #9 + WORD $0xaa0203ef // mov x15, x2 + WORD $0x54fffec8 // b.hi LBB0_544 $-40(%rip) +LBB0_546: + WORD $0x0b0701cf // add w15, w14, w7 + WORD $0xeb2fc15f // cmp x10, w15, sxtw + WORD $0x1a8a81ea // csel w10, w15, w10, hi + WORD $0x0b0d01cd // add w13, w14, w13 + WORD $0x7100055f // cmp w10, #1 + WORD $0x540001cb // b.lt LBB0_551 $56(%rip) + WORD $0x8b09014e // add x14, x10, x9 + WORD $0x385ff1ce // ldurb w14, [x14, #-1] + WORD $0x7100c1df // cmp w14, #48 + WORD $0x54000161 // b.ne LBB0_552 $44(%rip) +LBB0_548: + WORD $0xf100054e // subs x14, x10, #1 + WORD $0x54000789 // b.ls LBB0_568 $240(%rip) + WORD $0x5100094a // sub w10, w10, #2 + WORD $0x386a492f // ldrb w15, [x9, w10, uxtw] + WORD $0xaa0e03ea // mov x10, x14 + WORD $0x7100c1ff // cmp w15, #48 + WORD $0x54ffff40 // b.eq LBB0_548 $-24(%rip) + WORD $0xaa0e03ea // mov x10, x14 + WORD $0x14000002 // b LBB0_552 $8(%rip) +LBB0_551: + WORD $0x3400098a // cbz w10, LBB0_574 $304(%rip) +LBB0_552: + WORD $0x710051bf // cmp w13, #20 + WORD $0x5400006d // b.le LBB0_554 $12(%rip) + WORD $0x92800009 // mov x9, #-1 + WORD $0x14000054 // b LBB0_579 $336(%rip) +LBB0_554: + WORD $0x710005bf // cmp w13, #1 + WORD $0x5400028b // b.lt LBB0_559 $80(%rip) + WORD $0xd280000e // mov x14, #0 + WORD $0x7100015f // cmp w10, #0 + WORD $0x1a9fc150 // csel w16, w10, wzr, gt + WORD $0x2a0d03f1 // mov w17, w13 + WORD $0xd100062f // sub x15, x17, #1 + WORD $0xeb1001ff // cmp x15, x16 + WORD $0x9a9031ef // csel x15, x15, x16, lo + WORD $0x910005e1 // add x1, x15, #1 + WORD $0x52800142 // mov w2, #10 + WORD $0xaa0903e4 // mov x4, x9 +LBB0_556: + WORD $0xb4000170 // cbz x16, LBB0_560 $44(%rip) + WORD $0x38801485 // ldrsb x5, [x4], #1 + WORD $0x9b0215ce // madd x14, x14, x2, x5 + WORD $0xd100c1ce // sub x14, x14, #48 + WORD $0xd1000610 // sub x16, x16, #1 + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0xb5ffff51 // cbnz x17, LBB0_556 $-24(%rip) + WORD $0xaa0103ef // mov x15, x1 + WORD $0x14000003 // b LBB0_560 $12(%rip) +LBB0_559: + WORD $0x5280000f // mov w15, #0 + WORD $0xd280000e // mov x14, #0 +LBB0_560: + WORD $0x6b0f01b0 // subs w16, w13, w15 + WORD $0x540002ad // b.le LBB0_567 $84(%rip) + WORD $0x71000a1f // cmp w16, #2 + WORD $0x540001c3 // b.lo LBB0_565 $56(%rip) + WORD $0x121f7a11 // and w17, w16, #0xfffffffe + WORD $0x0b1101ef // add w15, w15, w17 + WORD $0x52800021 // mov w1, #1 + WORD $0xaa1103e2 // mov x2, x17 +LBB0_563: + WORD $0x8b0e09ce // add x14, x14, x14, lsl #2 + WORD $0xd37ff9ce // lsl x14, x14, #1 + WORD $0x8b010821 // add x1, x1, x1, lsl #2 + WORD $0xd37ff821 // lsl x1, x1, #1 + WORD $0x71000842 // subs w2, w2, #2 + WORD $0x54ffff61 // b.ne LBB0_563 $-20(%rip) + WORD $0x9b0e7c2e // mul x14, x1, x14 + WORD $0x6b11021f // cmp w16, w17 + WORD $0x540000c0 // b.eq LBB0_567 $24(%rip) +LBB0_565: + WORD $0x4b0f01af // sub w15, w13, w15 +LBB0_566: + WORD $0x8b0e09ce // add x14, x14, x14, lsl #2 + WORD $0xd37ff9ce // lsl x14, x14, #1 + WORD $0x710005ef // subs w15, w15, #1 + WORD $0x54ffffa1 // b.ne LBB0_566 $-12(%rip) +LBB0_567: + WORD $0x36f800ad // tbz w13, #31, LBB0_569 $20(%rip) + WORD $0x1400001a // b LBB0_575 $104(%rip) +LBB0_568: + WORD $0xd280000e // mov x14, #0 + WORD $0x5280000d // mov w13, #0 + WORD $0x5100054a // sub w10, w10, #1 +LBB0_569: + WORD $0x6b0d015f // cmp w10, w13 + WORD $0x540002ad // b.le LBB0_575 $84(%rip) + WORD $0x38ed492f // ldrsb w15, [x9, w13, uxtw] + WORD $0x110005b0 // add w16, w13, #1 + WORD $0x7100d5ff // cmp w15, #53 + WORD $0x7a4a0200 // ccmp w16, w10, #0, eq + WORD $0x54000100 // b.eq LBB0_572 $32(%rip) + WORD $0x7100d1ff // cmp w15, #52 + WORD $0x1a9fd7e9 // cset w9, gt + WORD $0x8b2941c9 // add x9, x14, w9, uxtw + WORD $0xd2e0040a // mov x10, #9007199254740992 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x540002a1 // b.ne LBB0_579 $84(%rip) + WORD $0x1400000e // b LBB0_576 $56(%rip) +LBB0_572: + WORD $0x3400034c // cbz w12, LBB0_581 $104(%rip) + WORD $0x52800029 // mov w9, #1 + WORD $0x8b2941c9 // add x9, x14, w9, uxtw + WORD $0xd2e0040a // mov x10, #9007199254740992 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x540001c1 // b.ne LBB0_579 $56(%rip) + WORD $0x14000007 // b LBB0_576 $28(%rip) +LBB0_574: + WORD $0xd280000e // mov x14, #0 +LBB0_575: + WORD $0x52800009 // mov w9, #0 + WORD $0x8b2941c9 // add x9, x14, w9, uxtw + WORD $0xd2e0040a // mov x10, #9007199254740992 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x540000e1 // b.ne LBB0_579 $28(%rip) +LBB0_576: + WORD $0x710ff91f // cmp w8, #1022 + WORD $0x54ff85ac // b.gt LBB0_306 $-3916(%rip) + WORD $0x11000508 // add w8, w8, #1 + WORD $0xd2e00209 // mov x9, #4503599627370496 + WORD $0x14000002 // b LBB0_579 $8(%rip) +LBB0_578: + WORD $0xd2800009 // mov x9, #0 +LBB0_579: + WORD $0x9374d12a // sbfx x10, x9, #52, #1 + WORD $0x110ffd08 // add w8, w8, #1023 + WORD $0x12002908 // and w8, w8, #0x7ff + WORD $0x8a08d148 // and x8, x10, x8, lsl #52 + WORD $0x17fffc2b // b LBB0_309 $-3924(%rip) +LBB0_580: + WORD $0x52800006 // mov w6, #0 + WORD $0x17fffd0f // b LBB0_371 $-3012(%rip) +LBB0_581: + WORD $0x34fffdcd // cbz w13, LBB0_575 $-72(%rip) + WORD $0x510005aa // sub w10, w13, #1 + WORD $0x386a4929 // ldrb w9, [x9, w10, uxtw] + WORD $0x12000129 // and w9, w9, #0x1 + WORD $0x8b2941c9 // add x9, x14, w9, uxtw + WORD $0xd2e0040a // mov x10, #9007199254740992 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x54fffe41 // b.ne LBB0_579 $-56(%rip) + WORD $0x17ffffeb // b LBB0_576 $-84(%rip) +LBB0_583: + WORD $0xd280000c // mov x12, #0 + WORD $0x8b02010d // add x13, x8, x2 + WORD $0x92800009 // mov x9, #-1 + WORD $0x9280000a // mov x10, #-1 + WORD $0xf100816e // subs x14, x11, #32 + WORD $0x54ff68a2 // b.hs LBB0_262 $-4844(%rip) + WORD $0x1400001e // b LBB0_588 $120(%rip) +LBB0_584: + WORD $0xd280000a // mov x10, #0 + WORD $0x8b02010c // add x12, x8, x2 + WORD $0x92800009 // mov x9, #-1 + WORD $0xf100816d // subs x13, x11, #32 + WORD $0x54ff6cc2 // b.hs LBB0_267 $-4712(%rip) + WORD $0x14000056 // b LBB0_605 $344(%rip) +LBB0_585: + WORD $0xdac001f0 // rbit x16, x15 + WORD $0xdac01210 // clz x16, x16 + WORD $0xcb0801b1 // sub x17, x13, x8 + WORD $0x8b110210 // add x16, x16, x17 + WORD $0xb100055f // cmn x10, #1 + WORD $0x9a901129 // csel x9, x9, x16, ne + WORD $0x9a90114a // csel x10, x10, x16, ne +LBB0_586: + WORD $0x0a2c01f0 // bic w16, w15, w12 + WORD $0x531f7a11 // lsl w17, w16, #1 + WORD $0x331f7a0c // bfi w12, w16, #1, #31 + WORD $0x0a3101ef // bic w15, w15, w17 + WORD $0x1201f1ef // and w15, w15, #0xaaaaaaaa + WORD $0x2b1001ef // adds w15, w15, w16 + WORD $0x3200f3f0 // mov w16, #1431655765 + WORD $0x4a0f060f // eor w15, w16, w15, lsl #1 + WORD $0x0a0c01ec // and w12, w15, w12 + WORD $0x1a9f37ef // cset w15, hs + WORD $0x2a2c03ec // mvn w12, w12 + WORD $0x8a0b018b // and x11, x12, x11 + WORD $0xaa0f03ec // mov x12, x15 + WORD $0xb5ff692b // cbnz x11, LBB0_265 $-4828(%rip) +LBB0_587: + WORD $0x910081ad // add x13, x13, #32 + WORD $0xaa0e03eb // mov x11, x14 +LBB0_588: + WORD $0xb5000c4c // cbnz x12, LBB0_617 $392(%rip) + WORD $0xb40003eb // cbz x11, LBB0_598 $124(%rip) +LBB0_590: + WORD $0xcb0803ec // neg x12, x8 + WORD $0x92800000 // mov x0, #-1 +LBB0_591: + WORD $0xd280000e // mov x14, #0 +LBB0_592: + WORD $0x386e69af // ldrb w15, [x13, x14] + WORD $0x710089ff // cmp w15, #34 + WORD $0x540002e0 // b.eq LBB0_597 $92(%rip) + WORD $0x710171ff // cmp w15, #92 + WORD $0x540000a0 // b.eq LBB0_595 $20(%rip) + WORD $0x910005ce // add x14, x14, #1 + WORD $0xeb0e017f // cmp x11, x14 + WORD $0x54ffff21 // b.ne LBB0_592 $-28(%rip) + WORD $0x14000016 // b LBB0_599 $88(%rip) +LBB0_595: + WORD $0xd100056f // sub x15, x11, #1 + WORD $0xeb0e01ff // cmp x15, x14 + WORD $0x54000c80 // b.eq LBB0_621 $400(%rip) + WORD $0x8b0d018f // add x15, x12, x13 + WORD $0x8b0e01ef // add x15, x15, x14 + WORD $0xb100055f // cmn x10, #1 + WORD $0x9a8901e9 // csel x9, x15, x9, eq + WORD $0x9a8a01ea // csel x10, x15, x10, eq + WORD $0x8b0e01ad // add x13, x13, x14 + WORD $0x910009ad // add x13, x13, #2 + WORD $0xcb0e016f // sub x15, x11, x14 + WORD $0xd1000970 // sub x16, x11, #2 + WORD $0xd10009eb // sub x11, x15, #2 + WORD $0xeb0e021f // cmp x16, x14 + WORD $0x54fffd01 // b.ne LBB0_591 $-96(%rip) + WORD $0x1400003f // b LBB0_615 $252(%rip) +LBB0_597: + WORD $0x8b0e01aa // add x10, x13, x14 + WORD $0x9100054d // add x13, x10, #1 +LBB0_598: + WORD $0xcb0801a0 // sub x0, x13, x8 + WORD $0xb6ff2420 // tbz x0, #63, LBB0_136 $-7036(%rip) + WORD $0x1400003a // b LBB0_615 $232(%rip) +LBB0_599: + WORD $0x710089ff // cmp w15, #34 + WORD $0x54000a01 // b.ne LBB0_621 $320(%rip) + WORD $0x8b0b01ad // add x13, x13, x11 + WORD $0x17fffffa // b LBB0_598 $-24(%rip) +LBB0_601: + WORD $0xdac001f0 // rbit x16, x15 + WORD $0xdac01210 // clz x16, x16 + WORD $0xcb080191 // sub x17, x12, x8 + WORD $0x8b100230 // add x16, x17, x16 + WORD $0xb100053f // cmn x9, #1 + WORD $0x9a901129 // csel x9, x9, x16, ne +LBB0_602: + WORD $0x0a2a01f0 // bic w16, w15, w10 + WORD $0x531f7a11 // lsl w17, w16, #1 + WORD $0x331f7a0a // bfi w10, w16, #1, #31 + WORD $0x0a3101ef // bic w15, w15, w17 + WORD $0x1201f1ef // and w15, w15, #0xaaaaaaaa + WORD $0x2b1001ef // adds w15, w15, w16 + WORD $0x3200f3f0 // mov w16, #1431655765 + WORD $0x4a0f060f // eor w15, w16, w15, lsl #1 + WORD $0x0a0a01ea // and w10, w15, w10 + WORD $0x1a9f37ef // cset w15, hs + WORD $0x2a2a03ea // mvn w10, w10 + WORD $0x8a0b014b // and x11, x10, x11 + WORD $0xaa0f03ea // mov x10, x15 + WORD $0xb5ff67eb // cbnz x11, LBB0_270 $-4868(%rip) +LBB0_603: + WORD $0x3500040e // cbnz w14, LBB0_614 $128(%rip) + WORD $0x9100818c // add x12, x12, #32 + WORD $0xaa0d03eb // mov x11, x13 +LBB0_605: + WORD $0xb50005ca // cbnz x10, LBB0_619 $184(%rip) + WORD $0xb40006ab // cbz x11, LBB0_621 $212(%rip) +LBB0_607: + WORD $0x9280002a // mov x10, #-2 + WORD $0x5280004d // mov w13, #2 + WORD $0x92800000 // mov x0, #-1 +LBB0_608: + WORD $0x3940018e // ldrb w14, [x12] + WORD $0x710089df // cmp w14, #34 + WORD $0x54000320 // b.eq LBB0_616 $100(%rip) + WORD $0x710171df // cmp w14, #92 + WORD $0x54000120 // b.eq LBB0_612 $36(%rip) + WORD $0x710081df // cmp w14, #32 + WORD $0x54000243 // b.lo LBB0_614 $72(%rip) + WORD $0x9280000e // mov x14, #-1 + WORD $0x5280002f // mov w15, #1 + WORD $0x8b0f018c // add x12, x12, x15 + WORD $0xab0b01cb // adds x11, x14, x11 + WORD $0x54fffea1 // b.ne LBB0_608 $-44(%rip) + WORD $0x1400000d // b LBB0_615 $52(%rip) +LBB0_612: + WORD $0xf100057f // cmp x11, #1 + WORD $0x54000460 // b.eq LBB0_621 $140(%rip) + WORD $0xcb08018e // sub x14, x12, x8 + WORD $0xb100053f // cmn x9, #1 + WORD $0x9a8e1129 // csel x9, x9, x14, ne + WORD $0x9a8d11af // csel x15, x13, x13, ne + WORD $0x9a8a114e // csel x14, x10, x10, ne + WORD $0x8b0f018c // add x12, x12, x15 + WORD $0xab0b01cb // adds x11, x14, x11 + WORD $0x54fffd41 // b.ne LBB0_608 $-88(%rip) + WORD $0x14000002 // b LBB0_615 $8(%rip) +LBB0_614: + WORD $0x92800020 // mov x0, #-2 +LBB0_615: + WORD $0xf9000060 // str x0, [x3] + WORD $0x17fff990 // b LBB0_193 $-6592(%rip) +LBB0_616: + WORD $0xcb080188 // sub x8, x12, x8 + WORD $0x91000500 // add x0, x8, #1 + WORD $0xb6ff1c40 // tbz x0, #63, LBB0_136 $-7288(%rip) + WORD $0x17fffffb // b LBB0_615 $-20(%rip) +LBB0_617: + WORD $0xb400024b // cbz x11, LBB0_621 $72(%rip) + WORD $0xaa2803ec // mvn x12, x8 + WORD $0x8b0c01ac // add x12, x13, x12 + WORD $0xb100055f // cmn x10, #1 + WORD $0x9a890189 // csel x9, x12, x9, eq + WORD $0x9a8a018a // csel x10, x12, x10, eq + WORD $0x910005ad // add x13, x13, #1 + WORD $0xd100056b // sub x11, x11, #1 + WORD $0xb5fff30b // cbnz x11, LBB0_590 $-416(%rip) + WORD $0x17ffffb5 // b LBB0_598 $-300(%rip) +LBB0_619: + WORD $0xb400010b // cbz x11, LBB0_621 $32(%rip) + WORD $0xaa2803ea // mvn x10, x8 + WORD $0x8b0a018a // add x10, x12, x10 + WORD $0xb100053f // cmn x9, #1 + WORD $0x9a890149 // csel x9, x10, x9, eq + WORD $0x9100058c // add x12, x12, #1 + WORD $0xd100056b // sub x11, x11, #1 + WORD $0xb5fff9ab // cbnz x11, LBB0_607 $-204(%rip) +LBB0_621: + WORD $0x92800000 // mov x0, #-1 + WORD $0x17ffffe7 // b LBB0_615 $-100(%rip) + // .p2align 1, 0x00 +LJTI0_0: + WORD $0x0118000f + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180121 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x00000105 + WORD $0x01180118 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x00000000 + WORD $0x01180185 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01890118 + WORD $0x01960118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x011801a3 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01180109 + WORD $0x01180118 + WORD $0x01180118 + WORD $0x0118018b + WORD $0x01180118 + WORD $0x01180118 + WORD $0x01ae0118 + WORD $0x01140118 + // // .word (LBB0_34-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_101-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_95-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_29-LBB0_29)>>2 +// .word (LBB0_112-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_113-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_117-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_119-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_96-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_114-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_122-LBB0_29)>>2 +// .word (LBB0_100-LBB0_29)>>2 +// .word (LBB0_99-LBB0_29)>>2 + +LJTI0_1: + WORD $0x17131d13 + WORD $0x1d1d1d1d + WORD $0x1d1d1d1d + WORD $0x1d1d1d1d + WORD $0x1d1d1d1d + WORD $0x1d1d1d1d + WORD $0x00001d1d + // // .byte (LBB0_71-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_71-LBB0_66)>>2 +// .byte (LBB0_72-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_74-LBB0_66)>>2 +// .byte (LBB0_66-LBB0_66)>>2 + +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + WORD $0x00000000 // .p2align 3, 0x00 +_P10_TAB: + WORD $0x00000000; WORD $0x3ff00000 // .quad 0x3ff0000000000000 + WORD $0x00000000; WORD $0x40240000 // .quad 0x4024000000000000 + WORD $0x00000000; WORD $0x40590000 // .quad 0x4059000000000000 + WORD $0x00000000; WORD $0x408f4000 // .quad 0x408f400000000000 + WORD $0x00000000; WORD $0x40c38800 // .quad 0x40c3880000000000 + WORD $0x00000000; WORD $0x40f86a00 // .quad 0x40f86a0000000000 + WORD $0x00000000; WORD $0x412e8480 // .quad 0x412e848000000000 + WORD $0x00000000; WORD $0x416312d0 // .quad 0x416312d000000000 + WORD $0x00000000; WORD $0x4197d784 // .quad 0x4197d78400000000 + WORD $0x00000000; WORD $0x41cdcd65 // .quad 0x41cdcd6500000000 + WORD $0x20000000; WORD $0x4202a05f // .quad 0x4202a05f20000000 + WORD $0xe8000000; WORD $0x42374876 // .quad 0x42374876e8000000 + WORD $0xa2000000; WORD $0x426d1a94 // .quad 0x426d1a94a2000000 + WORD $0xe5400000; WORD $0x42a2309c // .quad 0x42a2309ce5400000 + WORD $0x1e900000; WORD $0x42d6bcc4 // .quad 0x42d6bcc41e900000 + WORD $0x26340000; WORD $0x430c6bf5 // .quad 0x430c6bf526340000 + WORD $0x37e08000; WORD $0x4341c379 // .quad 0x4341c37937e08000 + WORD $0x85d8a000; WORD $0x43763457 // .quad 0x4376345785d8a000 + WORD $0x674ec800; WORD $0x43abc16d // .quad 0x43abc16d674ec800 + WORD $0x60913d00; WORD $0x43e158e4 // .quad 0x43e158e460913d00 + WORD $0x78b58c40; WORD $0x4415af1d // .quad 0x4415af1d78b58c40 + WORD $0xd6e2ef50; WORD $0x444b1ae4 // .quad 0x444b1ae4d6e2ef50 + WORD $0x064dd592; WORD $0x4480f0cf // .quad 0x4480f0cf064dd592 + // .p2align 3, 0x00 +_POW10_M128_TAB: + WORD $0xcd60e453; WORD $0x1732c869 // .quad 1671618768450675795 + WORD $0x081c0288; WORD $0xfa8fd5a0 // .quad -391859759250406776 + WORD $0x205c8eb4; WORD $0x0e7fbd42 // .quad 1044761730281672372 + WORD $0x05118195; WORD $0x9c99e584 // .quad -7162441377172586091 + WORD $0xa873b261; WORD $0x521fac92 // .quad 5917638181279478369 + WORD $0x0655e1fa; WORD $0xc3c05ee5 // .quad -4341365703038344710 + WORD $0x52909ef9; WORD $0xe6a797b7 // .quad -1826324310255427847 + WORD $0x47eb5a78; WORD $0xf4b0769e // .quad -815021110370542984 + WORD $0x939a635c; WORD $0x9028bed2 // .quad -8058981721550724260 + WORD $0xecf3188b; WORD $0x98ee4a22 // .quad -7426917221622671221 + WORD $0x3880fc33; WORD $0x7432ee87 // .quad 8373016921771146291 + WORD $0xa82fdeae; WORD $0xbf29dcab // .quad -4671960508600951122 + WORD $0x06a13b3f; WORD $0x113faa29 // .quad 1242899115359157055 + WORD $0x923bd65a; WORD $0xeef453d6 // .quad -1228264617323800998 + WORD $0xa424c507; WORD $0x4ac7ca59 // .quad 5388497965526861063 + WORD $0x1b6565f8; WORD $0x9558b466 // .quad -7685194413468457480 + WORD $0x0d2df649; WORD $0x5d79bcf0 // .quad 6735622456908576329 + WORD $0xa23ebf76; WORD $0xbaaee17f // .quad -4994806998408183946 + WORD $0x107973dc; WORD $0xf4d82c2c // .quad -803843965719055396 + WORD $0x8ace6f53; WORD $0xe95a99df // .quad -1631822729582842029 + WORD $0x8a4be869; WORD $0x79071b9b // .quad 8720969558280366185 + WORD $0xb6c10594; WORD $0x91d8a02b // .quad -7937418233630358124 + WORD $0x6cdee284; WORD $0x9748e282 // .quad -7545532125859093884 + WORD $0xa47146f9; WORD $0xb64ec836 // .quad -5310086773610559751 + WORD $0x08169b25; WORD $0xfd1b1b23 // .quad -208543120469091547 + WORD $0x4d8d98b7; WORD $0xe3e27a44 // .quad -2025922448585811785 + WORD $0xe50e20f7; WORD $0xfe30f0f5 // .quad -130339450293182217 + WORD $0xb0787f72; WORD $0x8e6d8c6a // .quad -8183730558007214222 + WORD $0x5e51a935; WORD $0xbdbd2d33 // .quad -4774610331293865675 + WORD $0x5c969f4f; WORD $0xb208ef85 // .quad -5617977179081629873 + WORD $0x35e61382; WORD $0xad2c7880 // .quad -5968262914117332094 + WORD $0xb3bc4723; WORD $0xde8b2b66 // .quad -2410785455424649437 + WORD $0x21afcc31; WORD $0x4c3bcb50 // .quad 5493207715531443249 + WORD $0x3055ac76; WORD $0x8b16fb20 // .quad -8424269937281487754 + WORD $0x2a1bbf3d; WORD $0xdf4abe24 // .quad -2356862392440471747 + WORD $0x3c6b1793; WORD $0xaddcb9e8 // .quad -5918651403174471789 + WORD $0x34a2af0d; WORD $0xd71d6dad // .quad -2946077990550589683 + WORD $0x4b85dd78; WORD $0xd953e862 // .quad -2786628235540701832 + WORD $0x40e5ad68; WORD $0x8672648c // .quad -8758827771735200408 + WORD $0x6f33aa6b; WORD $0x87d4713d // .quad -8659171674854020501 + WORD $0x511f18c2; WORD $0x680efdaf // .quad 7498209359040551106 + WORD $0xcb009506; WORD $0xa9c98d8c // .quad -6212278575140137722 + WORD $0x2566def2; WORD $0x0212bd1b // .quad 149389661945913074 + WORD $0xfdc0ba48; WORD $0xd43bf0ef // .quad -3153662200497784248 + WORD $0xf7604b57; WORD $0x014bb630 // .quad 93368538716195671 + WORD $0xfe98746d; WORD $0x84a57695 // .quad -8888567902952197011 + WORD $0x35385e2d; WORD $0x419ea3bd // .quad 4728396691822632493 + WORD $0x7e3e9188; WORD $0xa5ced43b // .quad -6499023860262858360 + WORD $0x828675b9; WORD $0x52064cac // .quad 5910495864778290617 + WORD $0x5dce35ea; WORD $0xcf42894a // .quad -3512093806901185046 + WORD $0xd1940993; WORD $0x7343efeb // .quad 8305745933913819539 + WORD $0x7aa0e1b2; WORD $0x818995ce // .quad -9112587656954322510 + WORD $0xc5f90bf8; WORD $0x1014ebe6 // .quad 1158810380537498616 + WORD $0x19491a1f; WORD $0xa1ebfb42 // .quad -6779048552765515233 + WORD $0x77774ef6; WORD $0xd41a26e0 // .quad -3163173042755514634 + WORD $0x9f9b60a6; WORD $0xca66fa12 // .quad -3862124672529506138 + WORD $0x955522b4; WORD $0x8920b098 // .quad -8565652321871781196 + WORD $0x478238d0; WORD $0xfd00b897 // .quad -215969822234494768 + WORD $0x5d5535b0; WORD $0x55b46e5f // .quad 6175682344898606512 + WORD $0x8cb16382; WORD $0x9e20735e // .quad -7052510166537641086 + WORD $0x34aa831d; WORD $0xeb2189f7 // .quad -1503769105731517667 + WORD $0x2fddbc62; WORD $0xc5a89036 // .quad -4203951689744663454 + WORD $0x01d523e4; WORD $0xa5e9ec75 // .quad -6491397400591784988 + WORD $0xbbd52b7b; WORD $0xf712b443 // .quad -643253593753441413 + WORD $0x2125366e; WORD $0x47b233c9 // .quad 5166248661484910190 + WORD $0x55653b2d; WORD $0x9a6bb0aa // .quad -7319562523736982739 + WORD $0x696e840a; WORD $0x999ec0bb // .quad -7377247228426025974 + WORD $0xeabe89f8; WORD $0xc1069cd4 // .quad -4537767136243840520 + WORD $0x43ca250d; WORD $0xc00670ea // .quad -4609873017105144563 + WORD $0x256e2c76; WORD $0xf148440a // .quad -1060522901877412746 + WORD $0x6a5e5728; WORD $0x38040692 // .quad 4036358391950366504 + WORD $0x5764dbca; WORD $0x96cd2a86 // .quad -7580355841314464822 + WORD $0x04f5ecf2; WORD $0xc6050837 // .quad -4177924046916817678 + WORD $0xed3e12bc; WORD $0xbc807527 // .quad -4863758783215693124 + WORD $0xc633682e; WORD $0xf7864a44 // .quad -610719040218634194 + WORD $0xe88d976b; WORD $0xeba09271 // .quad -1468012460592228501 + WORD $0xfbe0211d; WORD $0x7ab3ee6a // .quad 8841672636718129437 + WORD $0x31587ea3; WORD $0x93445b87 // .quad -7835036815511224669 + WORD $0xbad82964; WORD $0x5960ea05 // .quad 6440404777470273892 + WORD $0xfdae9e4c; WORD $0xb8157268 // .quad -5182110000961642932 + WORD $0x298e33bd; WORD $0x6fb92487 // .quad 8050505971837842365 + WORD $0x3d1a45df; WORD $0xe61acf03 // .quad -1865951482774665761 + WORD $0x79f8e056; WORD $0xa5d3b6d4 // .quad -6497648813669818282 + WORD $0x06306bab; WORD $0x8fd0c162 // .quad -8083748704375247957 + WORD $0x9877186c; WORD $0x8f48a489 // .quad -8122061017087272852 + WORD $0x87bc8696; WORD $0xb3c4f1ba // .quad -5492999862041672042 + WORD $0xfe94de87; WORD $0x331acdab // .quad 3682481783923072647 + WORD $0x29aba83c; WORD $0xe0b62e29 // .quad -2254563809124702148 + WORD $0x7f1d0b14; WORD $0x9ff0c08b // .quad -6921820921902855404 + WORD $0xba0b4925; WORD $0x8c71dcd9 // .quad -8326631408344020699 + WORD $0x5ee44dd9; WORD $0x07ecf0ae // .quad 571095884476206553 + WORD $0x288e1b6f; WORD $0xaf8e5410 // .quad -5796603242002637969 + WORD $0xf69d6150; WORD $0xc9e82cd9 // .quad -3897816162832129712 + WORD $0x32b1a24a; WORD $0xdb71e914 // .quad -2634068034075909558 + WORD $0x3a225cd2; WORD $0xbe311c08 // .quad -4741978110983775022 + WORD $0x9faf056e; WORD $0x892731ac // .quad -8563821548938525330 + WORD $0x48aaf406; WORD $0x6dbd630a // .quad 7907585416552444934 + WORD $0xc79ac6ca; WORD $0xab70fe17 // .quad -6093090917745768758 + WORD $0xdad5b108; WORD $0x092cbbcc // .quad 661109733835780360 + WORD $0xb981787d; WORD $0xd64d3d9d // .quad -3004677628754823043 + WORD $0x08c58ea5; WORD $0x25bbf560 // .quad 2719036592861056677 + WORD $0x93f0eb4e; WORD $0x85f04682 // .quad -8795452545612846258 + WORD $0x0af6f24e; WORD $0xaf2af2b8 // .quad -5824576295778454962 + WORD $0x38ed2621; WORD $0xa76c5823 // .quad -6382629663588669919 + WORD $0x0db4aee1; WORD $0x1af5af66 // .quad 1942651667131707105 + WORD $0x07286faa; WORD $0xd1476e2c // .quad -3366601061058449494 + WORD $0xc890ed4d; WORD $0x50d98d9f // .quad 5825843310384704845 + WORD $0x847945ca; WORD $0x82cca4db // .quad -9021654690802612790 + WORD $0xbab528a0; WORD $0xe50ff107 // .quad -1941067898873894752 + WORD $0x6597973c; WORD $0xa37fce12 // .quad -6665382345075878084 + WORD $0xa96272c8; WORD $0x1e53ed49 // .quad 2185351144835019464 + WORD $0xfefd7d0c; WORD $0xcc5fc196 // .quad -3720041912917459700 + WORD $0x13bb0f7a; WORD $0x25e8e89c // .quad 2731688931043774330 + WORD $0xbebcdc4f; WORD $0xff77b1fc // .quad -38366372719436721 + WORD $0x8c54e9ac; WORD $0x77b19161 // .quad 8624834609543440812 + WORD $0xf73609b1; WORD $0x9faacf3d // .quad -6941508010590729807 + WORD $0xef6a2417; WORD $0xd59df5b9 // .quad -3054014793352862697 + WORD $0x75038c1d; WORD $0xc795830d // .quad -4065198994811024355 + WORD $0x6b44ad1d; WORD $0x4b057328 // .quad 5405853545163697437 + WORD $0xd2446f25; WORD $0xf97ae3d0 // .quad -469812725086392539 + WORD $0x430aec32; WORD $0x4ee367f9 // .quad 5684501474941004850 + WORD $0x836ac577; WORD $0x9becce62 // .quad -7211161980820077193 + WORD $0x93cda73f; WORD $0x229c41f7 // .quad 2493940825248868159 + WORD $0x244576d5; WORD $0xc2e801fb // .quad -4402266457597708587 + WORD $0x78c1110f; WORD $0x6b435275 // .quad 7729112049988473103 + WORD $0xed56d48a; WORD $0xf3a20279 // .quad -891147053569747830 + WORD $0x6b78aaa9; WORD $0x830a1389 // .quad -9004363024039368023 + WORD $0x345644d6; WORD $0x9845418c // .quad -7474495936122174250 + WORD $0xc656d553; WORD $0x23cc986b // .quad 2579604275232953683 + WORD $0x416bd60c; WORD $0xbe5691ef // .quad -4731433901725329908 + WORD $0xb7ec8aa8; WORD $0x2cbfbe86 // .quad 3224505344041192104 + WORD $0x11c6cb8f; WORD $0xedec366b // .quad -1302606358729274481 + WORD $0x32f3d6a9; WORD $0x7bf7d714 // .quad 8932844867666826921 + WORD $0xeb1c3f39; WORD $0x94b3a202 // .quad -7731658001846878407 + WORD $0x3fb0cc53; WORD $0xdaf5ccd9 // .quad -2669001970698630061 + WORD $0xa5e34f07; WORD $0xb9e08a83 // .quad -5052886483881210105 + WORD $0x8f9cff68; WORD $0xd1b3400f // .quad -3336252463373287576 + WORD $0x8f5c22c9; WORD $0xe858ad24 // .quad -1704422086424124727 + WORD $0xb9c21fa1; WORD $0x23100809 // .quad 2526528228819083169 + WORD $0xd99995be; WORD $0x91376c36 // .quad -7982792831656159810 + WORD $0x2832a78a; WORD $0xabd40a0c // .quad -6065211750830921846 + WORD $0x8ffffb2d; WORD $0xb5854744 // .quad -5366805021142811859 + WORD $0x323f516c; WORD $0x16c90c8f // .quad 1641857348316123500 + WORD $0xb3fff9f9; WORD $0xe2e69915 // .quad -2096820258001126919 + WORD $0x7f6792e3; WORD $0xae3da7d9 // .quad -5891368184943504669 + WORD $0x907ffc3b; WORD $0x8dd01fad // .quad -8228041688891786181 + WORD $0xdf41779c; WORD $0x99cd11cf // .quad -7364210231179380836 + WORD $0xf49ffb4a; WORD $0xb1442798 // .quad -5673366092687344822 + WORD $0xd711d583; WORD $0x40405643 // .quad 4629795266307937667 + WORD $0x31c7fa1d; WORD $0xdd95317f // .quad -2480021597431793123 + WORD $0x666b2572; WORD $0x482835ea // .quad 5199465050656154994 + WORD $0x7f1cfc52; WORD $0x8a7d3eef // .quad -8467542526035952558 + WORD $0x0005eecf; WORD $0xda324365 // .quad -2724040723534582065 + WORD $0x5ee43b66; WORD $0xad1c8eab // .quad -5972742139117552794 + WORD $0x40076a82; WORD $0x90bed43e // .quad -8016736922845615486 + WORD $0x369d4a40; WORD $0xd863b256 // .quad -2854241655469553088 + WORD $0xe804a291; WORD $0x5a7744a6 // .quad 6518754469289960081 + WORD $0xe2224e68; WORD $0x873e4f75 // .quad -8701430062309552536 + WORD $0xa205cb36; WORD $0x711515d0 // .quad 8148443086612450102 + WORD $0x5aaae202; WORD $0xa90de353 // .quad -6265101559459552766 + WORD $0xca873e03; WORD $0x0d5a5b44 // .quad 962181821410786819 + WORD $0x31559a83; WORD $0xd3515c28 // .quad -3219690930897053053 + WORD $0xfe9486c2; WORD $0xe858790a // .quad -1704479370831952190 + WORD $0x1ed58091; WORD $0x8412d999 // .quad -8929835859451740015 + WORD $0xbe39a872; WORD $0x626e974d // .quad 7092772823314835570 + WORD $0x668ae0b6; WORD $0xa5178fff // .quad -6550608805887287114 + WORD $0x2dc8128f; WORD $0xfb0a3d21 // .quad -357406007711231345 + WORD $0x402d98e3; WORD $0xce5d73ff // .quad -3576574988931720989 + WORD $0xbc9d0b99; WORD $0x7ce66634 // .quad 8999993282035256217 + WORD $0x881c7f8e; WORD $0x80fa687f // .quad -9152888395723407474 + WORD $0xebc44e80; WORD $0x1c1fffc1 // .quad 2026619565689294464 + WORD $0x6a239f72; WORD $0xa139029f // .quad -6829424476226871438 + WORD $0x66b56220; WORD $0xa327ffb2 // .quad -6690097579743157728 + WORD $0x44ac874e; WORD $0xc9874347 // .quad -3925094576856201394 + WORD $0x0062baa8; WORD $0x4bf1ff9f // .quad 5472436080603216552 + WORD $0x15d7a922; WORD $0xfbe91419 // .quad -294682202642863838 + WORD $0x603db4a9; WORD $0x6f773fc3 // .quad 8031958568804398249 + WORD $0xada6c9b5; WORD $0x9d71ac8f // .quad -7101705404292871755 + WORD $0x384d21d3; WORD $0xcb550fb4 // .quad -3795109844276665901 + WORD $0x99107c22; WORD $0xc4ce17b3 // .quad -4265445736938701790 + WORD $0x46606a48; WORD $0x7e2a53a1 // .quad 9091170749936331336 + WORD $0x7f549b2b; WORD $0xf6019da0 // .quad -720121152745989333 + WORD $0xcbfc426d; WORD $0x2eda7444 // .quad 3376138709496513133 + WORD $0x4f94e0fb; WORD $0x99c10284 // .quad -7367604748107325189 + WORD $0xfefb5308; WORD $0xfa911155 // .quad -391512631556746488 + WORD $0x637a1939; WORD $0xc0314325 // .quad -4597819916706768583 + WORD $0x7eba27ca; WORD $0x793555ab // .quad 8733981247408842698 + WORD $0xbc589f88; WORD $0xf03d93ee // .quad -1135588877456072824 + WORD $0x2f3458de; WORD $0x4bc1558b // .quad 5458738279630526686 + WORD $0x35b763b5; WORD $0x96267c75 // .quad -7627272076051127371 + WORD $0xfb016f16; WORD $0x9eb1aaed // .quad -7011635205744005354 + WORD $0x83253ca2; WORD $0xbbb01b92 // .quad -4922404076636521310 + WORD $0x79c1cadc; WORD $0x465e15a9 // .quad 5070514048102157020 + WORD $0x23ee8bcb; WORD $0xea9c2277 // .quad -1541319077368263733 + WORD $0xec191ec9; WORD $0x0bfacd89 // .quad 863228270850154185 + WORD $0x7675175f; WORD $0x92a1958a // .quad -7880853450996246689 + WORD $0x671f667b; WORD $0xcef980ec // .quad -3532650679864695173 + WORD $0x14125d36; WORD $0xb749faed // .quad -5239380795317920458 + WORD $0x80e7401a; WORD $0x82b7e127 // .quad -9027499368258256870 + WORD $0x5916f484; WORD $0xe51c79a8 // .quad -1937539975720012668 + WORD $0xb0908810; WORD $0xd1b2ecb8 // .quad -3336344095947716592 + WORD $0x37ae58d2; WORD $0x8f31cc09 // .quad -8128491512466089774 + WORD $0xdcb4aa15; WORD $0x861fa7e6 // .quad -8782116138362033643 + WORD $0x8599ef07; WORD $0xb2fe3f0b // .quad -5548928372155224313 + WORD $0x93e1d49a; WORD $0x67a791e0 // .quad 7469098900757009562 + WORD $0x67006ac9; WORD $0xdfbdcece // .quad -2324474446766642487 + WORD $0x5c6d24e0; WORD $0xe0c8bb2c // .quad -2249342214667950880 + WORD $0x006042bd; WORD $0x8bd6a141 // .quad -8370325556870233411 + WORD $0x73886e18; WORD $0x58fae9f7 // .quad 6411694268519837208 + WORD $0x4078536d; WORD $0xaecc4991 // .quad -5851220927660403859 + WORD $0x506a899e; WORD $0xaf39a475 // .quad -5820440219632367202 + WORD $0x90966848; WORD $0xda7f5bf5 // .quad -2702340141148116920 + WORD $0x52429603; WORD $0x6d8406c9 // .quad 7891439908798240259 + WORD $0x7a5e012d; WORD $0x888f9979 // .quad -8606491615858654931 + WORD $0xa6d33b83; WORD $0xc8e5087b // .quad -3970758169284363389 + WORD $0xd8f58178; WORD $0xaab37fd7 // .quad -6146428501395930760 + WORD $0x90880a64; WORD $0xfb1e4a9a // .quad -351761693178066332 + WORD $0xcf32e1d6; WORD $0xd5605fcd // .quad -3071349608317525546 + WORD $0x9a55067f; WORD $0x5cf2eea0 // .quad 6697677969404790399 + WORD $0xa17fcd26; WORD $0x855c3be0 // .quad -8837122532839535322 + WORD $0xc0ea481e; WORD $0xf42faa48 // .quad -851274575098787810 + WORD $0xc9dfc06f; WORD $0xa6b34ad8 // .quad -6434717147622031249 + WORD $0xf124da26; WORD $0xf13b94da // .quad -1064093218873484762 + WORD $0xfc57b08b; WORD $0xd0601d8e // .quad -3431710416100151157 + WORD $0xd6b70858; WORD $0x76c53d08 // .quad 8558313775058847832 + WORD $0x5db6ce57; WORD $0x823c1279 // .quad -9062348037703676329 + WORD $0x0c64ca6e; WORD $0x54768c4b // .quad 6086206200396171886 + WORD $0xb52481ed; WORD $0xa2cb1717 // .quad -6716249028702207507 + WORD $0xcf7dfd09; WORD $0xa9942f5d // .quad -6227300304786948855 + WORD $0xa26da268; WORD $0xcb7ddcdd // .quad -3783625267450371480 + WORD $0x435d7c4c; WORD $0xd3f93b35 // .quad -3172439362556298164 + WORD $0x0b090b02; WORD $0xfe5d5415 // .quad -117845565885576446 + WORD $0x4a1a6daf; WORD $0xc47bc501 // .quad -4288617610811380305 + WORD $0x26e5a6e1; WORD $0x9efa548d // .quad -6991182506319567135 + WORD $0x9ca1091b; WORD $0x359ab641 // .quad 3862600023340550427 + WORD $0x709f109a; WORD $0xc6b8e9b0 // .quad -4127292114472071014 + WORD $0x03c94b62; WORD $0xc30163d2 // .quad -4395122007679087774 + WORD $0x8cc6d4c0; WORD $0xf867241c // .quad -547429124662700864 + WORD $0x425dcf1d; WORD $0x79e0de63 // .quad 8782263791269039901 + WORD $0xd7fc44f8; WORD $0x9b407691 // .quad -7259672230555269896 + WORD $0x12f542e4; WORD $0x985915fc // .quad -7468914334623251740 + WORD $0x4dfb5636; WORD $0xc2109436 // .quad -4462904269766699466 + WORD $0x17b2939d; WORD $0x3e6f5b7b // .quad 4498915137003099037 + WORD $0xe17a2bc4; WORD $0xf294b943 // .quad -966944318780986428 + WORD $0xeecf9c42; WORD $0xa705992c // .quad -6411550076227838910 + WORD $0x6cec5b5a; WORD $0x979cf3ca // .quad -7521869226879198374 + WORD $0x2a838353; WORD $0x50c6ff78 // .quad 5820620459997365075 + WORD $0x08277231; WORD $0xbd8430bd // .quad -4790650515171610063 + WORD $0x35246428; WORD $0xa4f8bf56 // .quad -6559282480285457368 + WORD $0x4a314ebd; WORD $0xece53cec // .quad -1376627125537124675 + WORD $0xe136be99; WORD $0x871b7795 // .quad -8711237568605798759 + WORD $0xae5ed136; WORD $0x940f4613 // .quad -7777920981101784778 + WORD $0x59846e3f; WORD $0x28e2557b // .quad 2946011094524915263 + WORD $0x99f68584; WORD $0xb9131798 // .quad -5110715207949843068 + WORD $0x2fe589cf; WORD $0x331aeada // .quad 3682513868156144079 + WORD $0xc07426e5; WORD $0xe757dd7e // .quad -1776707991509915931 + WORD $0x5def7621; WORD $0x3ff0d2c8 // .quad 4607414176811284001 + WORD $0x3848984f; WORD $0x9096ea6f // .quad -8027971522334779313 + WORD $0x756b53a9; WORD $0x0fed077a // .quad 1147581702586717097 + WORD $0x065abe63; WORD $0xb4bca50b // .quad -5423278384491086237 + WORD $0x12c62894; WORD $0xd3e84959 // .quad -3177208890193991532 + WORD $0xc7f16dfb; WORD $0xe1ebce4d // .quad -2167411962186469893 + WORD $0xabbbd95c; WORD $0x64712dd7 // .quad 7237616480483531100 + WORD $0x9cf6e4bd; WORD $0x8d3360f0 // .quad -8272161504007625539 + WORD $0x96aacfb3; WORD $0xbd8d794d // .quad -4788037454677749837 + WORD $0xc4349dec; WORD $0xb080392c // .quad -5728515861582144020 + WORD $0xfc5583a0; WORD $0xecf0d7a0 // .quad -1373360799919799392 + WORD $0xf541c567; WORD $0xdca04777 // .quad -2548958808550292121 + WORD $0x9db57244; WORD $0xf41686c4 // .quad -858350499949874620 + WORD $0xf9491b60; WORD $0x89e42caa // .quad -8510628282985014432 + WORD $0xc522ced5; WORD $0x311c2875 // .quad 3538747893490044629 + WORD $0xb79b6239; WORD $0xac5d37d5 // .quad -6026599335303880135 + WORD $0x366b828b; WORD $0x7d633293 // .quad 9035120885289943691 + WORD $0x25823ac7; WORD $0xd77485cb // .quad -2921563150702462265 + WORD $0x02033197; WORD $0xae5dff9c // .quad -5882264492762254953 + WORD $0xf77164bc; WORD $0x86a8d39e // .quad -8743505996830120772 + WORD $0x0283fdfc; WORD $0xd9f57f83 // .quad -2741144597525430788 + WORD $0xb54dbdeb; WORD $0xa8530886 // .quad -6317696477610263061 + WORD $0xc324fd7b; WORD $0xd072df63 // .quad -3426430746906788485 + WORD $0x62a12d66; WORD $0xd267caa8 // .quad -3285434578585440922 + WORD $0x59f71e6d; WORD $0x4247cb9e // .quad 4776009810824339053 + WORD $0x3da4bc60; WORD $0x8380dea9 // .quad -8970925639256982432 + WORD $0xf074e608; WORD $0x52d9be85 // .quad 5970012263530423816 + WORD $0x8d0deb78; WORD $0xa4611653 // .quad -6601971030643840136 + WORD $0x6c921f8b; WORD $0x67902e27 // .quad 7462515329413029771 + WORD $0x70516656; WORD $0xcd795be8 // .quad -3640777769877412266 + WORD $0xa3db53b6; WORD $0x00ba1cd8 // .quad 52386062455755702 + WORD $0x4632dff6; WORD $0x806bd971 // .quad -9193015133814464522 + WORD $0xccd228a4; WORD $0x80e8a40e // .quad -9157889458785081180 + WORD $0x97bf97f3; WORD $0xa086cfcd // .quad -6879582898840692749 + WORD $0x8006b2cd; WORD $0x6122cd12 // .quad 6999382250228200141 + WORD $0xfdaf7df0; WORD $0xc8a883c0 // .quad -3987792605123478032 + WORD $0x20085f81; WORD $0x796b8057 // .quad 8749227812785250177 + WORD $0x3d1b5d6c; WORD $0xfad2a4b1 // .quad -373054737976959636 + WORD $0x74053bb0; WORD $0xcbe33036 // .quad -3755104653863994448 + WORD $0xc6311a63; WORD $0x9cc3a6ee // .quad -7150688238876681629 + WORD $0x11068a9c; WORD $0xbedbfc44 // .quad -4693880817329993060 + WORD $0x77bd60fc; WORD $0xc3f490aa // .quad -4326674280168464132 + WORD $0x15482d44; WORD $0xee92fb55 // .quad -1255665003235103420 + WORD $0x15acb93b; WORD $0xf4f1b4d5 // .quad -796656831783192261 + WORD $0x2d4d1c4a; WORD $0x751bdd15 // .quad 8438581409832836170 + WORD $0x2d8bf3c5; WORD $0x99171105 // .quad -7415439547505577019 + WORD $0x78a0635d; WORD $0xd262d45a // .quad -3286831292991118499 + WORD $0x78eef0b6; WORD $0xbf5cd546 // .quad -4657613415954583370 + WORD $0x16c87c34; WORD $0x86fb8971 // .quad -8720225134666286028 + WORD $0x172aace4; WORD $0xef340a98 // .quad -1210330751515841308 + WORD $0xae3d4da0; WORD $0xd45d35e6 // .quad -3144297699952734816 + WORD $0x0e7aac0e; WORD $0x9580869f // .quad -7673985747338482674 + WORD $0x59cca109; WORD $0x89748360 // .quad -8542058143368306423 + WORD $0xd2195712; WORD $0xbae0a846 // .quad -4980796165745715438 + WORD $0x703fc94b; WORD $0x2bd1a438 // .quad 3157485376071780683 + WORD $0x869facd7; WORD $0xe998d258 // .quad -1614309188754756393 + WORD $0x4627ddcf; WORD $0x7b6306a3 // .quad 8890957387685944783 + WORD $0x5423cc06; WORD $0x91ff8377 // .quad -7926472270612804602 + WORD $0x17b1d542; WORD $0x1a3bc84c // .quad 1890324697752655170 + WORD $0x292cbf08; WORD $0xb67f6455 // .quad -5296404319838617848 + WORD $0x1d9e4a93; WORD $0x20caba5f // .quad 2362905872190818963 + WORD $0x7377eeca; WORD $0xe41f3d6a // .quad -2008819381370884406 + WORD $0x7282ee9c; WORD $0x547eb47b // .quad 6088502188546649756 + WORD $0x882af53e; WORD $0x8e938662 // .quad -8173041140997884610 + WORD $0x4f23aa43; WORD $0xe99e619a // .quad -1612744301171463613 + WORD $0x2a35b28d; WORD $0xb23867fb // .quad -5604615407819967859 + WORD $0xe2ec94d4; WORD $0x6405fa00 // .quad 7207441660390446292 + WORD $0xf4c31f31; WORD $0xdec681f9 // .quad -2394083241347571919 + WORD $0x8dd3dd04; WORD $0xde83bc40 // .quad -2412877989897052924 + WORD $0x38f9f37e; WORD $0x8b3c113c // .quad -8413831053483314306 + WORD $0xb148d445; WORD $0x9624ab50 // .quad -7627783505798704059 + WORD $0x4738705e; WORD $0xae0b158b // .quad -5905602798426754978 + WORD $0xdd9b0957; WORD $0x3badd624 // .quad 4300328673033783639 + WORD $0x19068c76; WORD $0xd98ddaee // .quad -2770317479606055818 + WORD $0x0a80e5d6; WORD $0xe54ca5d7 // .quad -1923980597781273130 + WORD $0xcfa417c9; WORD $0x87f8a8d4 // .quad -8648977452394866743 + WORD $0xcd211f4c; WORD $0x5e9fcf4c // .quad 6818396289628184396 + WORD $0x038d1dbc; WORD $0xa9f6d30a // .quad -6199535797066195524 + WORD $0x0069671f; WORD $0x7647c320 // .quad 8522995362035230495 + WORD $0x8470652b; WORD $0xd47487cc // .quad -3137733727905356501 + WORD $0x0041e073; WORD $0x29ecd9f4 // .quad 3021029092058325107 + WORD $0xd2c63f3b; WORD $0x84c8d4df // .quad -8878612607581929669 + WORD $0x00525890; WORD $0xf4681071 // .quad -835399653354481520 + WORD $0xc777cf09; WORD $0xa5fb0a17 // .quad -6486579741050024183 + WORD $0x4066eeb4; WORD $0x7182148d // .quad 8179122470161673908 + WORD $0xb955c2cc; WORD $0xcf79cc9d // .quad -3496538657885142324 + WORD $0x48405530; WORD $0xc6f14cd8 // .quad -4111420493003729616 + WORD $0x93d599bf; WORD $0x81ac1fe2 // .quad -9102865688819295809 + WORD $0x5a506a7c; WORD $0xb8ada00e // .quad -5139275616254662020 + WORD $0x38cb002f; WORD $0xa21727db // .quad -6766896092596731857 + WORD $0xf0e4851c; WORD $0xa6d90811 // .quad -6424094520318327524 + WORD $0x06fdc03b; WORD $0xca9cf1d2 // .quad -3846934097318526917 + WORD $0x6d1da663; WORD $0x908f4a16 // .quad -8030118150397909405 + WORD $0x88bd304a; WORD $0xfd442e46 // .quad -196981603220770742 + WORD $0x043287fe; WORD $0x9a598e4e // .quad -7324666853212387330 + WORD $0x15763e2e; WORD $0x9e4a9cec // .quad -7040642529654063570 + WORD $0x853f29fd; WORD $0x40eff1e1 // .quad 4679224488766679549 + WORD $0x1ad3cdba; WORD $0xc5dd4427 // .quad -4189117143640191558 + WORD $0xe68ef47c; WORD $0xd12bee59 // .quad -3374341425896426372 + WORD $0xe188c128; WORD $0xf7549530 // .quad -624710411122851544 + WORD $0x301958ce; WORD $0x82bb74f8 // .quad -9026492418826348338 + WORD $0x8cf578b9; WORD $0x9a94dd3e // .quad -7307973034592864071 + WORD $0x3c1faf01; WORD $0xe36a5236 // .quad -2059743486678159615 + WORD $0x3032d6e7; WORD $0xc13a148e // .quad -4523280274813692185 + WORD $0xcb279ac1; WORD $0xdc44e6c3 // .quad -2574679358347699519 + WORD $0xbc3f8ca1; WORD $0xf18899b1 // .quad -1042414325089727327 + WORD $0x5ef8c0b9; WORD $0x29ab103a // .quad 3002511419460075705 + WORD $0x15a7b7e5; WORD $0x96f5600f // .quad -7569037980822161435 + WORD $0xf6b6f0e7; WORD $0x7415d448 // .quad 8364825292752482535 + WORD $0xdb11a5de; WORD $0xbcb2b812 // .quad -4849611457600313890 + WORD $0x3464ad21; WORD $0x111b495b // .quad 1232659579085827361 + WORD $0x91d60f56; WORD $0xebdf6617 // .quad -1450328303573004458 + WORD $0x00beec34; WORD $0xcab10dd9 // .quad -3841273781498745804 + WORD $0xbb25c995; WORD $0x936b9fce // .quad -7823984217374209643 + WORD $0x40eea742; WORD $0x3d5d514f // .quad 4421779809981343554 + WORD $0x69ef3bfb; WORD $0xb84687c2 // .quad -5168294253290374149 + WORD $0x112a5112; WORD $0x0cb4a5a3 // .quad 915538744049291538 + WORD $0x046b0afa; WORD $0xe65829b3 // .quad -1848681798185579782 + WORD $0xeaba72ab; WORD $0x47f0e785 // .quad 5183897733458195115 + WORD $0xe2c2e6dc; WORD $0x8ff71a0f // .quad -8072955151507069220 + WORD $0x65690f56; WORD $0x59ed2167 // .quad 6479872166822743894 + WORD $0xdb73a093; WORD $0xb3f4e093 // .quad -5479507920956448621 + WORD $0x3ec3532c; WORD $0x306869c1 // .quad 3488154190101041964 + WORD $0xd25088b8; WORD $0xe0f218b8 // .quad -2237698882768172872 + WORD $0xc73a13fb; WORD $0x1e414218 // .quad 2180096368813151227 + WORD $0x83725573; WORD $0x8c974f73 // .quad -8316090829371189901 + WORD $0xf90898fa; WORD $0xe5d1929e // .quad -1886565557410948870 + WORD $0x644eeacf; WORD $0xafbd2350 // .quad -5783427518286599473 + WORD $0xb74abf39; WORD $0xdf45f746 // .quad -2358206946763686087 + WORD $0x7d62a583; WORD $0xdbac6c24 // .quad -2617598379430861437 + WORD $0x328eb783; WORD $0x6b8bba8c // .quad 7749492695127472003 + WORD $0xce5da772; WORD $0x894bc396 // .quad -8553528014785370254 + WORD $0x3f326564; WORD $0x066ea92f // .quad 463493832054564196 + WORD $0x81f5114f; WORD $0xab9eb47c // .quad -6080224000054324913 + WORD $0x0efefebd; WORD $0xc80a537b // .quad -4032318728359182659 + WORD $0xa27255a2; WORD $0xd686619b // .quad -2988593981640518238 + WORD $0xe95f5f36; WORD $0xbd06742c // .quad -4826042214438183114 + WORD $0x45877585; WORD $0x8613fd01 // .quad -8785400266166405755 + WORD $0x23b73704; WORD $0x2c481138 // .quad 3190819268807046916 + WORD $0x96e952e7; WORD $0xa798fc41 // .quad -6370064314280619289 + WORD $0x2ca504c5; WORD $0xf75a1586 // .quad -623161932418579259 + WORD $0xfca3a7a0; WORD $0xd17f3b51 // .quad -3350894374423386208 + WORD $0xdbe722fb; WORD $0x9a984d73 // .quad -7307005235402693893 + WORD $0x3de648c4; WORD $0x82ef8513 // .quad -9011838011655698236 + WORD $0xd2e0ebba; WORD $0xc13e60d0 // .quad -4522070525825979462 + WORD $0x0d5fdaf5; WORD $0xa3ab6658 // .quad -6653111496142234891 + WORD $0x079926a8; WORD $0x318df905 // .quad 3570783879572301480 + WORD $0x10b7d1b3; WORD $0xcc963fee // .quad -3704703351750405709 + WORD $0x497f7052; WORD $0xfdf17746 // .quad -148206168962011054 + WORD $0x94e5c61f; WORD $0xffbbcfe9 // .quad -19193171260619233 + WORD $0xedefa633; WORD $0xfeb6ea8b // .quad -92628855601256909 + WORD $0xfd0f9bd3; WORD $0x9fd561f1 // .quad -6929524759678968877 + WORD $0xe96b8fc0; WORD $0xfe64a52e // .quad -115786069501571136 + WORD $0x7c5382c8; WORD $0xc7caba6e // .quad -4050219931171323192 + WORD $0xa3c673b0; WORD $0x3dfdce7a // .quad 4466953431550423984 + WORD $0x1b68637b; WORD $0xf9bd690a // .quad -451088895536766085 + WORD $0xa65c084e; WORD $0x06bea10c // .quad 486002885505321038 + WORD $0x51213e2d; WORD $0x9c1661a6 // .quad -7199459587351560659 + WORD $0xcff30a62; WORD $0x486e494f // .quad 5219189625309039202 + WORD $0xe5698db8; WORD $0xc31bfa0f // .quad -4387638465762062920 + WORD $0xc3efccfa; WORD $0x5a89dba3 // .quad 6523987031636299002 + WORD $0xdec3f126; WORD $0xf3e2f893 // .quad -872862063775190746 + WORD $0x5a75e01c; WORD $0xf8962946 // .quad -534194123654701028 + WORD $0x6b3a76b7; WORD $0x986ddb5c // .quad -7463067817500576073 + WORD $0xf1135823; WORD $0xf6bbb397 // .quad -667742654568376285 + WORD $0x86091465; WORD $0xbe895233 // .quad -4717148753448332187 + WORD $0xed582e2c; WORD $0x746aa07d // .quad 8388693718644305452 + WORD $0x678b597f; WORD $0xee2ba6c0 // .quad -1284749923383027329 + WORD $0xb4571cdc; WORD $0xa8c2a44e // .quad -6286281471915778852 + WORD $0x40b717ef; WORD $0x94db4838 // .quad -7720497729755473937 + WORD $0x616ce413; WORD $0x92f34d62 // .quad -7857851839894723565 + WORD $0x50e4ddeb; WORD $0xba121a46 // .quad -5038936143766954517 + WORD $0xf9c81d17; WORD $0x77b020ba // .quad 8624429273841147159 + WORD $0xe51e1566; WORD $0xe896a0d7 // .quad -1686984161281305242 + WORD $0xdc1d122e; WORD $0x0ace1474 // .quad 778582277723329070 + WORD $0xef32cd60; WORD $0x915e2486 // .quad -7971894128441897632 + WORD $0x132456ba; WORD $0x0d819992 // .quad 973227847154161338 + WORD $0xaaff80b8; WORD $0xb5b5ada8 // .quad -5353181642124984136 + WORD $0x97ed6c69; WORD $0x10e1fff6 // .quad 1216534808942701673 + WORD $0xd5bf60e6; WORD $0xe3231912 // .quad -2079791034228842266 + WORD $0x1ef463c1; WORD $0xca8d3ffa // .quad -3851351762838199359 + WORD $0xc5979c8f; WORD $0x8df5efab // .quad -8217398424034108273 + WORD $0xa6b17cb2; WORD $0xbd308ff8 // .quad -4814189703547749198 + WORD $0xb6fd83b3; WORD $0xb1736b96 // .quad -5660062011615247437 + WORD $0xd05ddbde; WORD $0xac7cb3f6 // .quad -6017737129434686498 + WORD $0x64bce4a0; WORD $0xddd0467c // .quad -2463391496091671392 + WORD $0x423aa96b; WORD $0x6bcdf07a // .quad 7768129340171790699 + WORD $0xbef60ee4; WORD $0x8aa22c0d // .quad -8457148712698376476 + WORD $0xd2c953c6; WORD $0x86c16c98 // .quad -8736582398494813242 + WORD $0x2eb3929d; WORD $0xad4ab711 // .quad -5959749872445582691 + WORD $0x077ba8b7; WORD $0xe871c7bf // .quad -1697355961263740745 + WORD $0x7a607744; WORD $0xd89d64d5 // .quad -2838001322129590460 + WORD $0x64ad4972; WORD $0x11471cd7 // .quad 1244995533423855986 + WORD $0x6c7c4a8b; WORD $0x87625f05 // .quad -8691279853972075893 + WORD $0x3dd89bcf; WORD $0xd598e40d // .quad -3055441601647567921 + WORD $0xc79b5d2d; WORD $0xa93af6c6 // .quad -6252413799037706963 + WORD $0x8d4ec2c3; WORD $0x4aff1d10 // .quad 5404070034795315907 + WORD $0x79823479; WORD $0xd389b478 // .quad -3203831230369745799 + WORD $0x585139ba; WORD $0xcedf722a // .quad -3539985255894009414 + WORD $0x4bf160cb; WORD $0x843610cb // .quad -8919923546622172981 + WORD $0xee658828; WORD $0xc2974eb4 // .quad -4424981569867511768 + WORD $0x1eedb8fe; WORD $0xa54394fe // .quad -6538218414850328322 + WORD $0x29feea32; WORD $0x733d2262 // .quad 8303831092947774002 + WORD $0xa6a9273e; WORD $0xce947a3d // .quad -3561087000135522498 + WORD $0x5a3f525f; WORD $0x0806357d // .quad 578208414664970847 + WORD $0x8829b887; WORD $0x811ccc66 // .quad -9143208402725783417 + WORD $0xb0cf26f7; WORD $0xca07c2dc // .quad -3888925500096174345 + WORD $0x2a3426a8; WORD $0xa163ff80 // .quad -6817324484979841368 + WORD $0xdd02f0b5; WORD $0xfc89b393 // .quad -249470856692830027 + WORD $0x34c13052; WORD $0xc9bcff60 // .quad -3909969587797413806 + WORD $0xd443ace2; WORD $0xbbac2078 // .quad -4923524589293425438 + WORD $0x41f17c67; WORD $0xfc2c3f38 // .quad -275775966319379353 + WORD $0x84aa4c0d; WORD $0xd54b944b // .quad -3077202868308390899 + WORD $0x2936edc0; WORD $0x9d9ba783 // .quad -7089889006590693952 + WORD $0x65d4df11; WORD $0x0a9e795e // .quad 765182433041899281 + WORD $0xf384a931; WORD $0xc5029163 // .quad -4250675239810979535 + WORD $0xff4a16d5; WORD $0x4d4617b5 // .quad 5568164059729762005 + WORD $0xf065d37d; WORD $0xf64335bc // .quad -701658031336336515 + WORD $0xbf8e4e45; WORD $0x504bced1 // .quad 5785945546544795205 + WORD $0x163fa42e; WORD $0x99ea0196 // .quad -7356065297226292178 + WORD $0x2f71e1d6; WORD $0xe45ec286 // .quad -1990940103673781802 + WORD $0x9bcf8d39; WORD $0xc06481fb // .quad -4583395603105477319 + WORD $0xbb4e5a4c; WORD $0x5d767327 // .quad 6734696907262548556 + WORD $0x82c37088; WORD $0xf07da27a // .quad -1117558485454458744 + WORD $0xd510f86f; WORD $0x3a6a07f8 // .quad 4209185567039092847 + WORD $0x91ba2655; WORD $0x964e858c // .quad -7616003081050118571 + WORD $0x0a55368b; WORD $0x890489f7 // .quad -8573576096483297653 + WORD $0xb628afea; WORD $0xbbe226ef // .quad -4908317832885260310 + WORD $0xccea842e; WORD $0x2b45ac74 // .quad 3118087934678041646 + WORD $0xa3b2dbe5; WORD $0xeadab0ab // .quad -1523711272679187483 + WORD $0x0012929d; WORD $0x3b0b8bc9 // .quad 4254647968387469981 + WORD $0x464fc96f; WORD $0x92c8ae6b // .quad -7869848573065574033 + WORD $0x40173744; WORD $0x09ce6ebb // .quad 706623942056949572 + WORD $0x17e3bbcb; WORD $0xb77ada06 // .quad -5225624697904579637 + WORD $0x101d0515; WORD $0xcc420a6a // .quad -3728406090856200939 + WORD $0x9ddcaabd; WORD $0xe5599087 // .quad -1920344853953336643 + WORD $0x4a12232d; WORD $0x9fa94682 // .quad -6941939825212513491 + WORD $0xc2a9eab6; WORD $0x8f57fa54 // .quad -8117744561361917258 + WORD $0xdc96abf9; WORD $0x47939822 // .quad 5157633273766521849 + WORD $0xf3546564; WORD $0xb32df8e9 // .quad -5535494683275008668 + WORD $0x93bc56f7; WORD $0x59787e2b // .quad 6447041592208152311 + WORD $0x70297ebd; WORD $0xdff97724 // .quad -2307682335666372931 + WORD $0x3c55b65a; WORD $0x57eb4edb // .quad 6335244004343789146 + WORD $0xc619ef36; WORD $0x8bfbea76 // .quad -8359830487432564938 + WORD $0x0b6b23f1; WORD $0xede62292 // .quad -1304317031425039375 + WORD $0x77a06b03; WORD $0xaefae514 // .quad -5838102090863318269 + WORD $0x8e45eced; WORD $0xe95fab36 // .quad -1630396289281299219 + WORD $0x958885c4; WORD $0xdab99e59 // .quad -2685941595151759932 + WORD $0x18ebb414; WORD $0x11dbcb02 // .quad 1286845328412881940 + WORD $0xfd75539b; WORD $0x88b402f7 // .quad -8596242524610931813 + WORD $0x9f26a119; WORD $0xd652bdc2 // .quad -3003129357911285479 + WORD $0xfcd2a881; WORD $0xaae103b5 // .quad -6133617137336276863 + WORD $0x46f0495f; WORD $0x4be76d33 // .quad 5469460339465668959 + WORD $0x7c0752a2; WORD $0xd59944a3 // .quad -3055335403242958174 + WORD $0x0c562ddb; WORD $0x6f70a440 // .quad 8030098730593431003 + WORD $0x2d8493a5; WORD $0x857fcae6 // .quad -8827113654667930715 + WORD $0x0f6bb952; WORD $0xcb4ccd50 // .quad -3797434642040374958 + WORD $0xb8e5b88e; WORD $0xa6dfbd9f // .quad -6422206049907525490 + WORD $0x1346a7a7; WORD $0x7e2000a4 // .quad 9088264752731695015 + WORD $0xa71f26b2; WORD $0xd097ad07 // .quad -3416071543957018958 + WORD $0x8c0c28c8; WORD $0x8ed40066 // .quad -8154892584824854328 + WORD $0xc873782f; WORD $0x825ecc24 // .quad -9052573742614218705 + WORD $0x2f0f32fa; WORD $0x72890080 // .quad 8253128342678483706 + WORD $0xfa90563b; WORD $0xa2f67f2d // .quad -6704031159840385477 + WORD $0x3ad2ffb9; WORD $0x4f2b40a0 // .quad 5704724409920716729 + WORD $0x79346bca; WORD $0xcbb41ef9 // .quad -3768352931373093942 + WORD $0x4987bfa8; WORD $0xe2f610c8 // .quad -2092466524453879896 + WORD $0xd78186bc; WORD $0xfea126b7 // .quad -98755145788979524 + WORD $0x2df4d7c9; WORD $0x0dd9ca7d // .quad 998051431430019017 + WORD $0xe6b0f436; WORD $0x9f24b832 // .quad -6979250993759194058 + WORD $0x79720dbb; WORD $0x91503d1c // .quad -7975807747567252037 + WORD $0xa05d3143; WORD $0xc6ede63f // .quad -4112377723771604669 + WORD $0x97ce912a; WORD $0x75a44c63 // .quad 8476984389250486570 + WORD $0x88747d94; WORD $0xf8a95fcf // .quad -528786136287117932 + WORD $0x3ee11aba; WORD $0xc986afbe // .quad -3925256793573221702 + WORD $0xb548ce7c; WORD $0x9b69dbe1 // .quad -7248020362820530564 + WORD $0xce996168; WORD $0xfbe85bad // .quad -294884973539139224 + WORD $0x229b021b; WORD $0xc24452da // .quad -4448339435098275301 + WORD $0x423fb9c3; WORD $0xfae27299 // .quad -368606216923924029 + WORD $0xab41c2a2; WORD $0xf2d56790 // .quad -948738275445456222 + WORD $0xc967d41a; WORD $0xdccd879f // .quad -2536221894791146470 + WORD $0x6b0919a5; WORD $0x97c560ba // .quad -7510490449794491995 + WORD $0xbbc1c920; WORD $0x5400e987 // .quad 6053094668365842720 + WORD $0x05cb600f; WORD $0xbdb6b8e9 // .quad -4776427043815727089 + WORD $0xaab23b68; WORD $0x290123e9 // .quad 2954682317029915496 + WORD $0x473e3813; WORD $0xed246723 // .quad -1358847786342270957 + WORD $0x0aaf6521; WORD $0xf9a0b672 // .quad -459166561069996767 + WORD $0x0c86e30b; WORD $0x9436c076 // .quad -7766808894105001205 + WORD $0x8d5b3e69; WORD $0xf808e40e // .quad -573958201337495959 + WORD $0x8fa89bce; WORD $0xb9447093 // .quad -5096825099203863602 + WORD $0x30b20e04; WORD $0xb60b1d12 // .quad -5329133770099257852 + WORD $0x7392c2c2; WORD $0xe7958cb8 // .quad -1759345355577441598 + WORD $0x5e6f48c2; WORD $0xb1c6f22b // .quad -5636551615525730110 + WORD $0x483bb9b9; WORD $0x90bd77f3 // .quad -8017119874876982855 + WORD $0x360b1af3; WORD $0x1e38aeb6 // .quad 2177682517447613171 + WORD $0x1a4aa828; WORD $0xb4ecd5f0 // .quad -5409713825168840664 + WORD $0xc38de1b0; WORD $0x25c6da63 // .quad 2722103146809516464 + WORD $0x20dd5232; WORD $0xe2280b6c // .quad -2150456263033662926 + WORD $0x5a38ad0e; WORD $0x579c487e // .quad 6313000485183335694 + WORD $0x948a535f; WORD $0x8d590723 // .quad -8261564192037121185 + WORD $0xf0c6d851; WORD $0x2d835a9d // .quad 3279564588051781713 + WORD $0x79ace837; WORD $0xb0af48ec // .quad -5715269221619013577 + WORD $0x6cf88e65; WORD $0xf8e43145 // .quad -512230283362660763 + WORD $0x98182244; WORD $0xdcdb1b27 // .quad -2532400508596379068 + WORD $0x641b58ff; WORD $0x1b8e9ecb // .quad 1985699082112030975 + WORD $0xbf0f156b; WORD $0x8a08f0f8 // .quad -8500279345513818773 + WORD $0x3d222f3f; WORD $0xe272467e // .quad -2129562165787349185 + WORD $0xeed2dac5; WORD $0xac8b2d36 // .quad -6013663163464885563 + WORD $0xcc6abb0f; WORD $0x5b0ed81d // .quad 6561419329620589327 + WORD $0xaa879177; WORD $0xd7adf884 // .quad -2905392935903719049 + WORD $0x9fc2b4e9; WORD $0x98e94712 // .quad -7428327965055601431 + WORD $0xea94baea; WORD $0x86ccbb52 // .quad -8733399612580906262 + WORD $0x47b36224; WORD $0x3f2398d7 // .quad 4549648098962661924 + WORD $0xa539e9a5; WORD $0xa87fea27 // .quad -6305063497298744923 + WORD $0x19a03aad; WORD $0x8eec7f0d // .quad -8147997931578836307 + WORD $0x8e88640e; WORD $0xd29fe4b1 // .quad -3269643353196043250 + WORD $0x300424ac; WORD $0x1953cf68 // .quad 1825030320404309164 + WORD $0xf9153e89; WORD $0x83a3eeee // .quad -8961056123388608887 + WORD $0x3c052dd7; WORD $0x5fa8c342 // .quad 6892973918932774359 + WORD $0xb75a8e2b; WORD $0xa48ceaaa // .quad -6589634135808373205 + WORD $0xcb06794d; WORD $0x3792f412 // .quad 4004531380238580045 + WORD $0x653131b6; WORD $0xcdb02555 // .quad -3625356651333078602 + WORD $0xbee40bd0; WORD $0xe2bbd88b // .quad -2108853905778275376 + WORD $0x5f3ebf11; WORD $0x808e1755 // .quad -9183376934724255983 + WORD $0xae9d0ec4; WORD $0x5b6aceae // .quad 6587304654631931588 + WORD $0xb70e6ed6; WORD $0xa0b19d2a // .quad -6867535149977932074 + WORD $0x5a445275; WORD $0xf245825a // .quad -989241218564861323 + WORD $0x64d20a8b; WORD $0xc8de0475 // .quad -3972732919045027189 + WORD $0xf0d56712; WORD $0xeed6e2f0 // .quad -1236551523206076654 + WORD $0xbe068d2e; WORD $0xfb158592 // .quad -354230130378896082 + WORD $0x9685606b; WORD $0x55464dd6 // .quad 6144684325637283947 + WORD $0xb6c4183d; WORD $0x9ced737b // .quad -7138922859127891907 + WORD $0x3c26b886; WORD $0xaa97e14c // .quad -6154202648235558778 + WORD $0xa4751e4c; WORD $0xc428d05a // .quad -4311967555482476980 + WORD $0x4b3066a8; WORD $0xd53dd99f // .quad -3081067291867060568 + WORD $0x4d9265df; WORD $0xf5330471 // .quad -778273425925708321 + WORD $0x8efe4029; WORD $0xe546a803 // .quad -1925667057416912855 + WORD $0xd07b7fab; WORD $0x993fe2c6 // .quad -7403949918844649557 + WORD $0x72bdd033; WORD $0xde985204 // .quad -2407083821771141069 + WORD $0x849a5f96; WORD $0xbf8fdb78 // .quad -4643251380128424042 + WORD $0x8f6d4440; WORD $0x963e6685 // .quad -7620540795641314240 + WORD $0xa5c0f77c; WORD $0xef73d256 // .quad -1192378206733142148 + WORD $0x79a44aa8; WORD $0xdde70013 // .quad -2456994988062127448 + WORD $0x27989aad; WORD $0x95a86376 // .quad -7662765406849295699 + WORD $0x580d5d52; WORD $0x5560c018 // .quad 6152128301777116498 + WORD $0xb17ec159; WORD $0xbb127c53 // .quad -4966770740134231719 + WORD $0x6e10b4a6; WORD $0xaab8f01e // .quad -6144897678060768090 + WORD $0x9dde71af; WORD $0xe9d71b68 // .quad -1596777406740401745 + WORD $0x04ca70e8; WORD $0xcab39613 // .quad -3840561048787980056 + WORD $0x62ab070d; WORD $0x92267121 // .quad -7915514906853832947 + WORD $0xc5fd0d22; WORD $0x3d607b97 // .quad 4422670725869800738 + WORD $0xbb55c8d1; WORD $0xb6b00d69 // .quad -5282707615139903279 + WORD $0xb77c506a; WORD $0x8cb89a7d // .quad -8306719647944912790 + WORD $0x2a2b3b05; WORD $0xe45c10c4 // .quad -1991698500497491195 + WORD $0x92adb242; WORD $0x77f3608e // .quad 8643358275316593218 + WORD $0x9a5b04e3; WORD $0x8eb98a7a // .quad -8162340590452013853 + WORD $0x37591ed3; WORD $0x55f038b2 // .quad 6192511825718353619 + WORD $0x40f1c61c; WORD $0xb267ed19 // .quad -5591239719637629412 + WORD $0xc52f6688; WORD $0x6b6c46de // .quad 7740639782147942024 + WORD $0x912e37a3; WORD $0xdf01e85f // .quad -2377363631119648861 + WORD $0x3b3da015; WORD $0x2323ac4b // .quad 2532056854628769813 + WORD $0xbabce2c6; WORD $0x8b61313b // .quad -8403381297090862394 + WORD $0x0a0d081a; WORD $0xabec975e // .quad -6058300968568813542 + WORD $0xa96c1b77; WORD $0xae397d8a // .quad -5892540602936190089 + WORD $0x8c904a21; WORD $0x96e7bd35 // .quad -7572876210711016927 + WORD $0x53c72255; WORD $0xd9c7dced // .quad -2753989735242849707 + WORD $0x77da2e54; WORD $0x7e50d641 // .quad 9102010423587778132 + WORD $0x545c7575; WORD $0x881cea14 // .quad -8638772612167862923 + WORD $0xd5d0b9e9; WORD $0xdde50bd1 // .quad -2457545025797441047 + WORD $0x697392d2; WORD $0xaa242499 // .quad -6186779746782440750 + WORD $0x4b44e864; WORD $0x955e4ec6 // .quad -7683617300674189212 + WORD $0xc3d07787; WORD $0xd4ad2dbf // .quad -3121788665050663033 + WORD $0xef0b113e; WORD $0xbd5af13b // .quad -4802260812921368258 + WORD $0xda624ab4; WORD $0x84ec3c97 // .quad -8868646943297746252 + WORD $0xeacdd58e; WORD $0xecb1ad8a // .quad -1391139997724322418 + WORD $0xd0fadd61; WORD $0xa6274bbd // .quad -6474122660694794911 + WORD $0xa5814af2; WORD $0x67de18ed // .quad 7484447039699372786 + WORD $0x453994ba; WORD $0xcfb11ead // .quad -3480967307441105734 + WORD $0x8770ced7; WORD $0x80eacf94 // .quad -9157278655470055721 + WORD $0x4b43fcf4; WORD $0x81ceb32c // .quad -9093133594791772940 + WORD $0xa94d028d; WORD $0xa1258379 // .quad -6834912300910181747 + WORD $0x5e14fc31; WORD $0xa2425ff7 // .quad -6754730975062328271 + WORD $0x13a04330; WORD $0x096ee458 // .quad 679731660717048624 + WORD $0x359a3b3e; WORD $0xcad2f7f5 // .quad -3831727700400522434 + WORD $0x188853fc; WORD $0x8bca9d6e // .quad -8373707460958465028 + WORD $0x8300ca0d; WORD $0xfd87b5f2 // .quad -177973607073265139 + WORD $0xcf55347d; WORD $0x775ea264 // .quad 8601490892183123069 + WORD $0x91e07e48; WORD $0x9e74d1b7 // .quad -7028762532061872568 + WORD $0x032a819d; WORD $0x95364afe // .quad -7694880458480647779 + WORD $0x76589dda; WORD $0xc6120625 // .quad -4174267146649952806 + WORD $0x83f52204; WORD $0x3a83ddbd // .quad 4216457482181353988 + WORD $0xd3eec551; WORD $0xf79687ae // .quad -606147914885053103 + WORD $0x72793542; WORD $0xc4926a96 // .quad -4282243101277735614 + WORD $0x44753b52; WORD $0x9abe14cd // .quad -7296371474444240046 + WORD $0x0f178293; WORD $0x75b7053c // .quad 8482254178684994195 + WORD $0x95928a27; WORD $0xc16d9a00 // .quad -4508778324627912153 + WORD $0x12dd6338; WORD $0x5324c68b // .quad 5991131704928854840 + WORD $0xbaf72cb1; WORD $0xf1c90080 // .quad -1024286887357502287 + WORD $0xebca5e03; WORD $0xd3f6fc16 // .quad -3173071712060547581 + WORD $0x74da7bee; WORD $0x971da050 // .quad -7557708332239520786 + WORD $0xa6bcf584; WORD $0x88f4bb1c // .quad -8578025658503072380 + WORD $0x92111aea; WORD $0xbce50864 // .quad -4835449396872013078 + WORD $0xd06c32e5; WORD $0x2b31e9e3 // .quad 3112525982153323237 + WORD $0xb69561a5; WORD $0xec1e4a7d // .quad -1432625727662628443 + WORD $0x62439fcf; WORD $0x3aff322e // .quad 4251171748059520975 + WORD $0x921d5d07; WORD $0x9392ee8e // .quad -7812920107430224633 + WORD $0xfad487c2; WORD $0x09befeb9 // .quad 702278666647013314 + WORD $0x36a4b449; WORD $0xb877aa32 // .quad -5154464115860392887 + WORD $0x7989a9b3; WORD $0x4c2ebe68 // .quad 5489534351736154547 + WORD $0xc44de15b; WORD $0xe69594be // .quad -1831394126398103205 + WORD $0x4bf60a10; WORD $0x0f9d3701 // .quad 1125115960621402640 + WORD $0x3ab0acd9; WORD $0x901d7cf7 // .quad -8062150356639896359 + WORD $0x9ef38c94; WORD $0x538484c1 // .quad 6018080969204141204 + WORD $0x095cd80f; WORD $0xb424dc35 // .quad -5466001927372482545 + WORD $0x06b06fb9; WORD $0x2865a5f2 // .quad 2910915193077788601 + WORD $0x4bb40e13; WORD $0xe12e1342 // .quad -2220816390788215277 + WORD $0x442e45d3; WORD $0xf93f87b7 // .quad -486521013540076077 + WORD $0x6f5088cb; WORD $0x8cbccc09 // .quad -8305539271883716405 + WORD $0x1539d748; WORD $0xf78f69a5 // .quad -608151266925095096 + WORD $0xcb24aafe; WORD $0xafebff0b // .quad -5770238071427257602 + WORD $0x5a884d1b; WORD $0xb573440e // .quad -5371875102083756773 + WORD $0xbdedd5be; WORD $0xdbe6fece // .quad -2601111570856684098 + WORD $0xf8953030; WORD $0x31680a88 // .quad 3560107088838733872 + WORD $0x36b4a597; WORD $0x89705f41 // .quad -8543223759426509417 + WORD $0x36ba7c3d; WORD $0xfdc20d2b // .quad -161552157378970563 + WORD $0x8461cefc; WORD $0xabcc7711 // .quad -6067343680855748868 + WORD $0x04691b4c; WORD $0x3d329076 // .quad 4409745821703674700 + WORD $0xe57a42bc; WORD $0xd6bf94d5 // .quad -2972493582642298180 + WORD $0xc2c1b10f; WORD $0xa63f9a49 // .quad -6467280898289979121 + WORD $0xaf6c69b5; WORD $0x8637bd05 // .quad -8775337516792518219 + WORD $0x33721d53; WORD $0x0fcf80dc // .quad 1139270913992301907 + WORD $0x1b478423; WORD $0xa7c5ac47 // .quad -6357485877563259869 + WORD $0x404ea4a8; WORD $0xd3c36113 // .quad -3187597375937010520 + WORD $0xe219652b; WORD $0xd1b71758 // .quad -3335171328526686933 + WORD $0x083126e9; WORD $0x645a1cac // .quad 7231123676894144233 + WORD $0x8d4fdf3b; WORD $0x83126e97 // .quad -9002011107970261189 + WORD $0x0a3d70a3; WORD $0x3d70a3d7 // .quad 4427218577690292387 + WORD $0x70a3d70a; WORD $0xa3d70a3d // .quad -6640827866535438582 + WORD $0xcccccccc // .space 4, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc' + WORD $0xcccccccc // .space 4, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc' + WORD $0xcccccccc // .space 4, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc' + WORD $0xcccccccc // .space 4, '\xcc\xcc\xcc\xcc' + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x80000000 // .quad -9223372036854775808 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xa0000000 // .quad -6917529027641081856 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xc8000000 // .quad -4035225266123964416 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xfa000000 // .quad -432345564227567616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x9c400000 // .quad -7187745005283311616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xc3500000 // .quad -4372995238176751616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xf4240000 // .quad -854558029293551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x98968000 // .quad -7451627795949551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xbebc2000 // .quad -4702848726509551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xee6b2800 // .quad -1266874889709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x9502f900 // .quad -7709325833709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xba43b740 // .quad -5024971273709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xe8d4a510 // .quad -1669528073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x9184e72a // .quad -7960984073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x80000000; WORD $0xb5e620f4 // .quad -5339544073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xa0000000; WORD $0xe35fa931 // .quad -2062744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x04000000; WORD $0x8e1bc9bf // .quad -8206744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xc5000000; WORD $0xb1a2bc2e // .quad -5646744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x76400000; WORD $0xde0b6b3a // .quad -2446744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x89e80000; WORD $0x8ac72304 // .quad -8446744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xac620000; WORD $0xad78ebc5 // .quad -5946744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x177a8000; WORD $0xd8d726b7 // .quad -2821744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x6eac9000; WORD $0x87867832 // .quad -8681119073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x0a57b400; WORD $0xa968163f // .quad -6239712823709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xcceda100; WORD $0xd3c21bce // .quad -3187955011209551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x401484a0; WORD $0x84595161 // .quad -8910000909647051616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x9019a5c8; WORD $0xa56fa5b9 // .quad -6525815118631426616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xf4200f3a; WORD $0xcecb8f27 // .quad -3545582879861895366 + WORD $0x00000000; WORD $0x40000000 // .quad 4611686018427387904 + WORD $0xf8940984; WORD $0x813f3978 // .quad -9133518327554766460 + WORD $0x00000000; WORD $0x50000000 // .quad 5764607523034234880 + WORD $0x36b90be5; WORD $0xa18f07d7 // .quad -6805211891016070171 + WORD $0x00000000; WORD $0xa4000000 // .quad -6629298651489370112 + WORD $0x04674ede; WORD $0xc9f2c9cd // .quad -3894828845342699810 + WORD $0x00000000; WORD $0x4d000000 // .quad 5548434740920451072 + WORD $0x45812296; WORD $0xfc6f7c40 // .quad -256850038250986858 + WORD $0x00000000; WORD $0xf0200000 // .quad -1143914305352105984 + WORD $0x2b70b59d; WORD $0x9dc5ada8 // .quad -7078060301547948643 + WORD $0x00000000; WORD $0x6c280000 // .quad 7793479155164643328 + WORD $0x364ce305; WORD $0xc5371912 // .quad -4235889358507547899 + WORD $0x00000000; WORD $0xc7320000 // .quad -4093209111326359552 + WORD $0xc3e01bc6; WORD $0xf684df56 // .quad -683175679707046970 + WORD $0x00000000; WORD $0x3c7f4000 // .quad 4359273333062107136 + WORD $0x3a6c115c; WORD $0x9a130b96 // .quad -7344513827457986212 + WORD $0x00000000; WORD $0x4b9f1000 // .quad 5449091666327633920 + WORD $0xc90715b3; WORD $0xc097ce7b // .quad -4568956265895094861 + WORD $0x00000000; WORD $0x1e86d400 // .quad 2199678564482154496 + WORD $0xbb48db20; WORD $0xf0bdc21a // .quad -1099509313941480672 + WORD $0x00000000; WORD $0x13144480 // .quad 1374799102801346560 + WORD $0xb50d88f4; WORD $0x96769950 // .quad -7604722348854507276 + WORD $0x00000000; WORD $0x17d955a0 // .quad 1718498878501683200 + WORD $0xe250eb31; WORD $0xbc143fa4 // .quad -4894216917640746191 + WORD $0x00000000; WORD $0x5dcfab08 // .quad 6759809616554491904 + WORD $0x1ae525fd; WORD $0xeb194f8e // .quad -1506085128623544835 + WORD $0x00000000; WORD $0x5aa1cae5 // .quad 6530724019560251392 + WORD $0xd0cf37be; WORD $0x92efd1b8 // .quad -7858832233030797378 + WORD $0x40000000; WORD $0xf14a3d9e // .quad -1059967012404461568 + WORD $0x050305ad; WORD $0xb7abc627 // .quad -5211854272861108819 + WORD $0xd0000000; WORD $0x6d9ccd05 // .quad 7898413271349198848 + WORD $0xc643c719; WORD $0xe596b7b0 // .quad -1903131822648998119 + WORD $0xa2000000; WORD $0xe4820023 // .quad -1981020733047832576 + WORD $0x7bea5c6f; WORD $0x8f7e32ce // .quad -8106986416796705681 + WORD $0x8a800000; WORD $0xdda2802c // .quad -2476275916309790720 + WORD $0x1ae4f38b; WORD $0xb35dbf82 // .quad -5522047002568494197 + WORD $0xad200000; WORD $0xd50b2037 // .quad -3095344895387238400 + WORD $0xa19e306e; WORD $0xe0352f62 // .quad -2290872734783229842 + WORD $0xcc340000; WORD $0x4526f422 // .quad 4982938468024057856 + WORD $0xa502de45; WORD $0x8c213d9d // .quad -8349324486880600507 + WORD $0x7f410000; WORD $0x9670b12b // .quad -7606384970252091392 + WORD $0x0e4395d6; WORD $0xaf298d05 // .quad -5824969590173362730 + WORD $0x5f114000; WORD $0x3c0cdd76 // .quad 4327076842467049472 + WORD $0x51d47b4c; WORD $0xdaf3f046 // .quad -2669525969289315508 + WORD $0xfb6ac800; WORD $0xa5880a69 // .quad -6518949010312869888 + WORD $0xf324cd0f; WORD $0x88d8762b // .quad -8585982758446904049 + WORD $0x7a457a00; WORD $0x8eea0d04 // .quad -8148686262891087360 + WORD $0xefee0053; WORD $0xab0e93b6 // .quad -6120792429631242157 + WORD $0x98d6d880; WORD $0x72a49045 // .quad 8260886245095692416 + WORD $0xabe98068; WORD $0xd5d238a4 // .quad -3039304518611664792 + WORD $0x7f864750; WORD $0x47a6da2b // .quad 5163053903184807760 + WORD $0xeb71f041; WORD $0x85a36366 // .quad -8817094351773372351 + WORD $0x5f67d924; WORD $0x999090b6 // .quad -7381240676301154012 + WORD $0xa64e6c51; WORD $0xa70c3c40 // .quad -6409681921289327535 + WORD $0xf741cf6d; WORD $0xfff4b4e3 // .quad -3178808521666707 + WORD $0xcfe20765; WORD $0xd0cf4b50 // .quad -3400416383184271515 + WORD $0x7a8921a4; WORD $0xbff8f10e // .quad -4613672773753429596 + WORD $0x81ed449f; WORD $0x82818f12 // .quad -9042789267131251553 + WORD $0x192b6a0d; WORD $0xaff72d52 // .quad -5767090967191786995 + WORD $0x226895c7; WORD $0xa321f2d7 // .quad -6691800565486676537 + WORD $0x9f764490; WORD $0x9bf4f8a6 // .quad -7208863708989733744 + WORD $0xeb02bb39; WORD $0xcbea6f8c // .quad -3753064688430957767 + WORD $0x4753d5b4; WORD $0x02f236d0 // .quad 212292400617608628 + WORD $0x25c36a08; WORD $0xfee50b70 // .quad -79644842111309304 + WORD $0x2c946590; WORD $0x01d76242 // .quad 132682750386005392 + WORD $0x179a2245; WORD $0x9f4f2726 // .quad -6967307053960650171 + WORD $0xb7b97ef5; WORD $0x424d3ad2 // .quad 4777539456409894645 + WORD $0x9d80aad6; WORD $0xc722f0ef // .quad -4097447799023424810 + WORD $0x65a7deb2; WORD $0xd2e08987 // .quad -3251447716342407502 + WORD $0x84e0d58b; WORD $0xf8ebad2b // .quad -510123730351893109 + WORD $0x9f88eb2f; WORD $0x63cc55f4 // .quad 7191217214140771119 + WORD $0x330c8577; WORD $0x9b934c3b // .quad -7236356359111015049 + WORD $0xc76b25fb; WORD $0x3cbf6b71 // .quad 4377335499248575995 + WORD $0xffcfa6d5; WORD $0xc2781f49 // .quad -4433759430461380907 + WORD $0x3945ef7a; WORD $0x8bef464e // .quad -8363388681221443718 + WORD $0x7fc3908a; WORD $0xf316271c // .quad -930513269649338230 + WORD $0xe3cbb5ac; WORD $0x97758bf0 // .quad -7532960934977096276 + WORD $0xcfda3a56; WORD $0x97edd871 // .quad -7499099821171918250 + WORD $0x1cbea317; WORD $0x3d52eeed // .quad 4418856886560793367 + WORD $0x43d0c8ec; WORD $0xbde94e8e // .quad -4762188758037509908 + WORD $0x63ee4bdd; WORD $0x4ca7aaa8 // .quad 5523571108200991709 + WORD $0xd4c4fb27; WORD $0xed63a231 // .quad -1341049929119499481 + WORD $0x3e74ef6a; WORD $0x8fe8caa9 // .quad -8076983103442849942 + WORD $0x24fb1cf8; WORD $0x945e455f // .quad -7755685233340769032 + WORD $0x8e122b44; WORD $0xb3e2fd53 // .quad -5484542860876174524 + WORD $0xee39e436; WORD $0xb975d6b6 // .quad -5082920523248573386 + WORD $0x7196b616; WORD $0x60dbbca8 // .quad 6979379479186945558 + WORD $0xa9c85d44; WORD $0xe7d34c64 // .quad -1741964635633328828 + WORD $0x46fe31cd; WORD $0xbc8955e9 // .quad -4861259862362934835 + WORD $0xea1d3a4a; WORD $0x90e40fbe // .quad -8006256924911912374 + WORD $0x98bdbe41; WORD $0x6babab63 // .quad 7758483227328495169 + WORD $0xa4a488dd; WORD $0xb51d13ae // .quad -5396135137712502563 + WORD $0x7eed2dd1; WORD $0xc696963c // .quad -4136954021121544751 + WORD $0x4dcdab14; WORD $0xe264589a // .quad -2133482903713240300 + WORD $0xcf543ca2; WORD $0xfc1e1de5 // .quad -279753253987271518 + WORD $0x70a08aec; WORD $0x8d7eb760 // .quad -8250955842461857044 + WORD $0x43294bcb; WORD $0x3b25a55f // .quad 4261994450943298507 + WORD $0x8cc8ada8; WORD $0xb0de6538 // .quad -5702008784649933400 + WORD $0x13f39ebe; WORD $0x49ef0eb7 // .quad 5327493063679123134 + WORD $0xaffad912; WORD $0xdd15fe86 // .quad -2515824962385028846 + WORD $0x6c784337; WORD $0x6e356932 // .quad 7941369183226839863 + WORD $0x2dfcc7ab; WORD $0x8a2dbf14 // .quad -8489919629131724885 + WORD $0x07965404; WORD $0x49c2c37f // .quad 5315025460606161924 + WORD $0x397bf996; WORD $0xacb92ed9 // .quad -6000713517987268202 + WORD $0xc97be906; WORD $0xdc33745e // .quad -2579590211097073402 + WORD $0x87daf7fb; WORD $0xd7e77a8f // .quad -2889205879056697349 + WORD $0x3ded71a3; WORD $0x69a028bb // .quad 7611128154919104931 + WORD $0xb4e8dafd; WORD $0x86f0ac99 // .quad -8723282702051517699 + WORD $0x0d68ce0c; WORD $0xc40832ea // .quad -4321147861633282548 + WORD $0x222311bc; WORD $0xa8acd7c0 // .quad -6292417359137009220 + WORD $0x90c30190; WORD $0xf50a3fa4 // .quad -789748808614215280 + WORD $0x2aabd62b; WORD $0xd2d80db0 // .quad -3253835680493873621 + WORD $0xda79e0fa; WORD $0x792667c6 // .quad 8729779031470891258 + WORD $0x1aab65db; WORD $0x83c7088e // .quad -8951176327949752869 + WORD $0x91185938; WORD $0x577001b8 // .quad 6300537770911226168 + WORD $0xa1563f52; WORD $0xa4b8cab1 // .quad -6577284391509803182 + WORD $0xb55e6f86; WORD $0xed4c0226 // .quad -1347699823215743098 + WORD $0x09abcf26; WORD $0xcde6fd5e // .quad -3609919470959866074 + WORD $0x315b05b4; WORD $0x544f8158 // .quad 6075216638131242420 + WORD $0xc60b6178; WORD $0x80b05e5a // .quad -9173728696990998152 + WORD $0x3db1c721; WORD $0x696361ae // .quad 7594020797664053025 + WORD $0x778e39d6; WORD $0xa0dc75f1 // .quad -6855474852811359786 + WORD $0xcd1e38e9; WORD $0x03bc3a19 // .quad 269153960225290473 + WORD $0xd571c84c; WORD $0xc913936d // .quad -3957657547586811828 + WORD $0x4065c723; WORD $0x04ab48a0 // .quad 336442450281613091 + WORD $0x4ace3a5f; WORD $0xfb587849 // .quad -335385916056126881 + WORD $0x283f9c76; WORD $0x62eb0d64 // .quad 7127805559067090038 + WORD $0xcec0e47b; WORD $0x9d174b2d // .quad -7127145225176161157 + WORD $0x324f8394; WORD $0x3ba5d0bd // .quad 4298070930406474644 + WORD $0x42711d9a; WORD $0xc45d1df9 // .quad -4297245513042813542 + WORD $0x7ee36479; WORD $0xca8f44ec // .quad -3850783373846682503 + WORD $0x930d6500; WORD $0xf5746577 // .quad -759870872876129024 + WORD $0xcf4e1ecb; WORD $0x7e998b13 // .quad 9122475437414293195 + WORD $0xbbe85f20; WORD $0x9968bf6a // .quad -7392448323188662496 + WORD $0xc321a67e; WORD $0x9e3fedd8 // .quad -7043649776941685122 + WORD $0x6ae276e8; WORD $0xbfc2ef45 // .quad -4628874385558440216 + WORD $0xf3ea101e; WORD $0xc5cfe94e // .quad -4192876202749718498 + WORD $0xc59b14a2; WORD $0xefb3ab16 // .quad -1174406963520662366 + WORD $0x58724a12; WORD $0xbba1f1d1 // .quad -4926390635932268014 + WORD $0x3b80ece5; WORD $0x95d04aee // .quad -7651533379841495835 + WORD $0xae8edc97; WORD $0x2a8a6e45 // .quad 3065383741939440791 + WORD $0xca61281f; WORD $0xbb445da9 // .quad -4952730706374481889 + WORD $0x1a3293bd; WORD $0xf52d09d7 // .quad -779956341003086915 + WORD $0x3cf97226; WORD $0xea157514 // .quad -1579227364540714458 + WORD $0x705f9c56; WORD $0x593c2626 // .quad 6430056314514152534 + WORD $0xa61be758; WORD $0x924d692c // .quad -7904546130479028392 + WORD $0x0c77836c; WORD $0x6f8b2fb0 // .quad 8037570393142690668 + WORD $0xcfa2e12e; WORD $0xb6e0c377 // .quad -5268996644671397586 + WORD $0x0f956447; WORD $0x0b6dfb9c // .quad 823590954573587527 + WORD $0xc38b997a; WORD $0xe498f455 // .quad -1974559787411859078 + WORD $0x89bd5eac; WORD $0x4724bd41 // .quad 5126430365035880108 + WORD $0x9a373fec; WORD $0x8edf98b5 // .quad -8151628894773493780 + WORD $0xec2cb657; WORD $0x58edec91 // .quad 6408037956294850135 + WORD $0x00c50fe7; WORD $0xb2977ee3 // .quad -5577850100039479321 + WORD $0x6737e3ed; WORD $0x2f2967b6 // .quad 3398361426941174765 + WORD $0xc0f653e1; WORD $0xdf3d5e9b // .quad -2360626606621961247 + WORD $0x0082ee74; WORD $0xbd79e0d2 // .quad -4793553135802847628 + WORD $0x5899f46c; WORD $0x8b865b21 // .quad -8392920656779807636 + WORD $0x80a3aa11; WORD $0xecd85906 // .quad -1380255401326171631 + WORD $0xaec07187; WORD $0xae67f1e9 // .quad -5879464802547371641 + WORD $0x20cc9495; WORD $0xe80e6f48 // .quad -1725319251657714539 + WORD $0x1a708de9; WORD $0xda01ee64 // .quad -2737644984756826647 + WORD $0x147fdcdd; WORD $0x3109058d // .quad 3533361486141316317 + WORD $0x908658b2; WORD $0x884134fe // .quad -8628557143114098510 + WORD $0x599fd415; WORD $0xbd4b46f0 // .quad -4806670179178130411 + WORD $0x34a7eede; WORD $0xaa51823e // .quad -6174010410465235234 + WORD $0x7007c91a; WORD $0x6c9e18ac // .quad 7826720331309500698 + WORD $0xc1d1ea96; WORD $0xd4e5e2cd // .quad -3105826994654156138 + WORD $0xc604ddb0; WORD $0x03e2cf6b // .quad 280014188641050032 + WORD $0x9923329e; WORD $0x850fadc0 // .quad -8858670899299929442 + WORD $0xb786151c; WORD $0x84db8346 // .quad -8873354301053463268 + WORD $0xbf6bff45; WORD $0xa6539930 // .quad -6461652605697523899 + WORD $0x65679a63; WORD $0xe6126418 // .quad -1868320839462053277 + WORD $0xef46ff16; WORD $0xcfe87f7c // .quad -3465379738694516970 + WORD $0x3f60c07e; WORD $0x4fcb7e8f // .quad 5749828502977298558 + WORD $0x158c5f6e; WORD $0x81f14fae // .quad -9083391364325154962 + WORD $0x0f38f09d; WORD $0xe3be5e33 // .quad -2036086408133152611 + WORD $0x9aef7749; WORD $0xa26da399 // .quad -6742553186979055799 + WORD $0xd3072cc5; WORD $0x5cadf5bf // .quad 6678264026688335045 + WORD $0x01ab551c; WORD $0xcb090c80 // .quad -3816505465296431844 + WORD $0xc7c8f7f6; WORD $0x73d9732f // .quad 8347830033360418806 + WORD $0x02162a63; WORD $0xfdcb4fa0 // .quad -158945813193151901 + WORD $0xdcdd9afa; WORD $0x2867e7fd // .quad 2911550761636567802 + WORD $0x014dda7e; WORD $0x9e9f11c4 // .quad -7016870160886801794 + WORD $0x541501b8; WORD $0xb281e1fd // .quad -5583933584809066056 + WORD $0x01a1511d; WORD $0xc646d635 // .quad -4159401682681114339 + WORD $0xa91a4226; WORD $0x1f225a7c // .quad 2243455055843443238 + WORD $0x4209a565; WORD $0xf7d88bc2 // .quad -587566084924005019 + WORD $0xe9b06958; WORD $0x3375788d // .quad 3708002419115845976 + WORD $0x6946075f; WORD $0x9ae75759 // .quad -7284757830718584993 + WORD $0x641c83ae; WORD $0x0052d6b1 // .quad 23317005467419566 + WORD $0xc3978937; WORD $0xc1a12d2f // .quad -4494261269970843337 + WORD $0xbd23a49a; WORD $0xc0678c5d // .quad -4582539761593113446 + WORD $0xb47d6b84; WORD $0xf209787b // .quad -1006140569036166268 + WORD $0x963646e0; WORD $0xf840b7ba // .quad -558244341782001952 + WORD $0x50ce6332; WORD $0x9745eb4d // .quad -7546366883288685774 + WORD $0x3bc3d898; WORD $0xb650e5a9 // .quad -5309491445654890344 + WORD $0xa501fbff; WORD $0xbd176620 // .quad -4821272585683469313 + WORD $0x8ab4cebe; WORD $0xa3e51f13 // .quad -6636864307068612930 + WORD $0xce427aff; WORD $0xec5d3fa8 // .quad -1414904713676948737 + WORD $0x36b10137; WORD $0xc66f336c // .quad -4148040191917883081 + WORD $0x80e98cdf; WORD $0x93ba47c9 // .quad -7801844473689174817 + WORD $0x445d4184; WORD $0xb80b0047 // .quad -5185050239897353852 + WORD $0xe123f017; WORD $0xb8a8d9bb // .quad -5140619573684080617 + WORD $0x157491e5; WORD $0xa60dc059 // .quad -6481312799871692315 + WORD $0xd96cec1d; WORD $0xe6d3102a // .quad -1814088448677712867 + WORD $0xad68db2f; WORD $0x87c89837 // .quad -8662506518347195601 + WORD $0xc7e41392; WORD $0x9043ea1a // .quad -8051334308064652398 + WORD $0x98c311fb; WORD $0x29babe45 // .quad 3006924907348169211 + WORD $0x79dd1877; WORD $0xb454e4a1 // .quad -5452481866653427593 + WORD $0xfef3d67a; WORD $0xf4296dd6 // .quad -853029884242176390 + WORD $0xd8545e94; WORD $0xe16a1dc9 // .quad -2203916314889396588 + WORD $0x5f58660c; WORD $0x1899e4a6 // .quad 1772699331562333708 + WORD $0x2734bb1d; WORD $0x8ce2529e // .quad -8294976724446954723 + WORD $0xf72e7f8f; WORD $0x5ec05dcf // .quad 6827560182880305039 + WORD $0xb101e9e4; WORD $0xb01ae745 // .quad -5757034887131305500 + WORD $0xf4fa1f73; WORD $0x76707543 // .quad 8534450228600381299 + WORD $0x1d42645d; WORD $0xdc21a117 // .quad -2584607590486743971 + WORD $0x791c53a8; WORD $0x6a06494a // .quad 7639874402088932264 + WORD $0x72497eba; WORD $0x899504ae // .quad -8532908771695296838 + WORD $0x17636892; WORD $0x0487db9d // .quad 326470965756389522 + WORD $0x0edbde69; WORD $0xabfa45da // .quad -6054449946191733143 + WORD $0x5d3c42b6; WORD $0x45a9d284 // .quad 5019774725622874806 + WORD $0x9292d603; WORD $0xd6f8d750 // .quad -2956376414312278525 + WORD $0xba45a9b2; WORD $0x0b8a2392 // .quad 831516194300602802 + WORD $0x5b9bc5c2; WORD $0x865b8692 // .quad -8765264286586255934 + WORD $0x68d7141e; WORD $0x8e6cac77 // .quad -8183976793979022306 + WORD $0xf282b732; WORD $0xa7f26836 // .quad -6344894339805432014 + WORD $0x430cd926; WORD $0x3207d795 // .quad 3605087062808385830 + WORD $0xaf2364ff; WORD $0xd1ef0244 // .quad -3319431906329402113 + WORD $0x49e807b8; WORD $0x7f44e6bd // .quad 9170708441896323000 + WORD $0xed761f1f; WORD $0x8335616a // .quad -8992173969096958177 + WORD $0x9c6209a6; WORD $0x5f16206c // .quad 6851699533943015846 + WORD $0xa8d3a6e7; WORD $0xa402b9c5 // .quad -6628531442943809817 + WORD $0xc37a8c0f; WORD $0x36dba887 // .quad 3952938399001381903 + WORD $0x130890a1; WORD $0xcd036837 // .quad -3673978285252374367 + WORD $0xda2c9789; WORD $0xc2494954 // .quad -4446942528265218167 + WORD $0x6be55a64; WORD $0x80222122 // .quad -9213765455923815836 + WORD $0x10b7bd6c; WORD $0xf2db9baa // .quad -946992141904134804 + WORD $0x06deb0fd; WORD $0xa02aa96b // .quad -6905520801477381891 + WORD $0x94e5acc7; WORD $0x6f928294 // .quad 8039631859474607303 + WORD $0xc8965d3d; WORD $0xc83553c5 // .quad -4020214983419339459 + WORD $0xba1f17f9; WORD $0xcb772339 // .quad -3785518230938904583 + WORD $0x3abbf48c; WORD $0xfa42a8b7 // .quad -413582710846786420 + WORD $0x14536efb; WORD $0xff2a7604 // .quad -60105885123121413 + WORD $0x84b578d7; WORD $0x9c69a972 // .quad -7176018221920323369 + WORD $0x19684aba; WORD $0xfef51385 // .quad -75132356403901766 + WORD $0x25e2d70d; WORD $0xc38413cf // .quad -4358336758973016307 + WORD $0x5fc25d69; WORD $0x7eb25866 // .quad 9129456591349898601 + WORD $0xef5b8cd1; WORD $0xf46518c2 // .quad -836234930288882479 + WORD $0xfbd97a61; WORD $0xef2f773f // .quad -1211618658047395231 + WORD $0xd5993802; WORD $0x98bf2f79 // .quad -7440175859071633406 + WORD $0xfacfd8fa; WORD $0xaafb550f // .quad -6126209340986631942 + WORD $0x4aff8603; WORD $0xbeeefb58 // .quad -4688533805412153853 + WORD $0xf983cf38; WORD $0x95ba2a53 // .quad -7657761676233289928 + WORD $0x5dbf6784; WORD $0xeeaaba2e // .quad -1248981238337804412 + WORD $0x7bf26183; WORD $0xdd945a74 // .quad -2480258038432112253 + WORD $0xfa97a0b2; WORD $0x952ab45c // .quad -7698142301602209614 + WORD $0x9aeef9e4; WORD $0x94f97111 // .quad -7712008566467528220 + WORD $0x393d88df; WORD $0xba756174 // .quad -5010991858575374113 + WORD $0x01aab85d; WORD $0x7a37cd56 // .quad 8806733365625141341 + WORD $0x478ceb17; WORD $0xe912b9d1 // .quad -1652053804791829737 + WORD $0xc10ab33a; WORD $0xac62e055 // .quad -6025006692552756422 + WORD $0xccb812ee; WORD $0x91abb422 // .quad -7950062655635975442 + WORD $0x314d6009; WORD $0x577b986b // .quad 6303799689591218185 + WORD $0x7fe617aa; WORD $0xb616a12b // .quad -5325892301117581398 + WORD $0xfda0b80b; WORD $0xed5a7e85 // .quad -1343622424865753077 + WORD $0x5fdf9d94; WORD $0xe39c4976 // .quad -2045679357969588844 + WORD $0xbe847307; WORD $0x14588f13 // .quad 1466078993672598279 + WORD $0xfbebc27d; WORD $0x8e41ade9 // .quad -8196078626372074883 + WORD $0xae258fc8; WORD $0x596eb2d8 // .quad 6444284760518135752 + WORD $0x7ae6b31c; WORD $0xb1d21964 // .quad -5633412264537705700 + WORD $0xd9aef3bb; WORD $0x6fca5f8e // .quad 8055355950647669691 + WORD $0x99a05fe3; WORD $0xde469fbd // .quad -2430079312244744221 + WORD $0x480d5854; WORD $0x25de7bb9 // .quad 2728754459941099604 + WORD $0x80043bee; WORD $0x8aec23d6 // .quad -8436328597794046994 + WORD $0x9a10ae6a; WORD $0xaf561aa7 // .quad -5812428961928401302 + WORD $0x20054ae9; WORD $0xada72ccc // .quad -5933724728815170839 + WORD $0x8094da04; WORD $0x1b2ba151 // .quad 1957835834444274180 + WORD $0x28069da4; WORD $0xd910f7ff // .quad -2805469892591575644 + WORD $0xf05d0842; WORD $0x90fb44d2 // .quad -7999724640327104446 + WORD $0x79042286; WORD $0x87aa9aff // .quad -8670947710510816634 + WORD $0xac744a53; WORD $0x353a1607 // .quad 3835402254873283155 + WORD $0x57452b28; WORD $0xa99541bf // .quad -6226998619711132888 + WORD $0x97915ce8; WORD $0x42889b89 // .quad 4794252818591603944 + WORD $0x2d1675f2; WORD $0xd3fa922f // .quad -3172062256211528206 + WORD $0xfebada11; WORD $0x69956135 // .quad 7608094030047140369 + WORD $0x7c2e09b7; WORD $0x847c9b5d // .quad -8900067937773286985 + WORD $0x7e699095; WORD $0x43fab983 // .quad 4898431519131537557 + WORD $0xdb398c25; WORD $0xa59bc234 // .quad -6513398903789220827 + WORD $0x5e03f4bb; WORD $0x94f967e4 // .quad -7712018656367741765 + WORD $0x1207ef2e; WORD $0xcf02b2c2 // .quad -3530062611309138130 + WORD $0xbac278f5; WORD $0x1d1be0ee // .quad 2097517367411243253 + WORD $0x4b44f57d; WORD $0x8161afb9 // .quad -9123818159709293187 + WORD $0x69731732; WORD $0x6462d92a // .quad 7233582727691441970 + WORD $0x9e1632dc; WORD $0xa1ba1ba7 // .quad -6793086681209228580 + WORD $0x03cfdcfe; WORD $0x7d7b8f75 // .quad 9041978409614302462 + WORD $0x859bbf93; WORD $0xca28a291 // .quad -3879672333084147821 + WORD $0x44c3d43e; WORD $0x5cda7352 // .quad 6690786993590490174 + WORD $0xe702af78; WORD $0xfcb2cb35 // .quad -237904397927796872 + WORD $0x6afa64a7; WORD $0x3a088813 // .quad 4181741870994056359 + WORD $0xb061adab; WORD $0x9defbf01 // .quad -7066219276345954901 + WORD $0x45b8fdd0; WORD $0x088aaa18 // .quad 615491320315182544 + WORD $0x1c7a1916; WORD $0xc56baec2 // .quad -4221088077005055722 + WORD $0x57273d45; WORD $0x8aad549e // .quad -8454007886460797627 + WORD $0xa3989f5b; WORD $0xf6c69a72 // .quad -664674077828931749 + WORD $0xf678864b; WORD $0x36ac54e2 // .quad 3939617107816777291 + WORD $0xa63f6399; WORD $0x9a3c2087 // .quad -7332950326284164199 + WORD $0xb416a7dd; WORD $0x84576a1b // .quad -8910536670511192099 + WORD $0x8fcf3c7f; WORD $0xc0cb28a9 // .quad -4554501889427817345 + WORD $0xa11c51d5; WORD $0x656d44a2 // .quad 7308573235570561493 + WORD $0xf3c30b9f; WORD $0xf0fdf2d3 // .quad -1081441343357383777 + WORD $0xa4b1b325; WORD $0x9f644ae5 // .quad -6961356773836868827 + WORD $0x7859e743; WORD $0x969eb7c4 // .quad -7593429867239446717 + WORD $0x0dde1fee; WORD $0x873d5d9f // .quad -8701695967296086034 + WORD $0x96706114; WORD $0xbc4665b5 // .quad -4880101315621920492 + WORD $0xd155a7ea; WORD $0xa90cb506 // .quad -6265433940692719638 + WORD $0xfc0c7959; WORD $0xeb57ff22 // .quad -1488440626100012711 + WORD $0x42d588f2; WORD $0x09a7f124 // .quad 695789805494438130 + WORD $0xdd87cbd8; WORD $0x9316ff75 // .quad -7847804418953589800 + WORD $0x538aeb2f; WORD $0x0c11ed6d // .quad 869737256868047663 + WORD $0x54e9bece; WORD $0xb7dcbf53 // .quad -5198069505264599346 + WORD $0xa86da5fa; WORD $0x8f1668c8 // .quad -8136200465769716230 + WORD $0x2a242e81; WORD $0xe5d3ef28 // .quad -1885900863153361279 + WORD $0x694487bc; WORD $0xf96e017d // .quad -473439272678684740 + WORD $0x1a569d10; WORD $0x8fa47579 // .quad -8096217067111932656 + WORD $0xc395a9ac; WORD $0x37c981dc // .quad 4019886927579031980 + WORD $0x60ec4455; WORD $0xb38d92d7 // .quad -5508585315462527915 + WORD $0xf47b1417; WORD $0x85bbe253 // .quad -8810199395808373737 + WORD $0x3927556a; WORD $0xe070f78d // .quad -2274045625900771990 + WORD $0x78ccec8e; WORD $0x93956d74 // .quad -7812217631593927538 + WORD $0x43b89562; WORD $0x8c469ab8 // .quad -8338807543829064350 + WORD $0x970027b2; WORD $0x387ac8d1 // .quad 4069786015789754290 + WORD $0x54a6babb; WORD $0xaf584166 // .quad -5811823411358942533 + WORD $0xfcc0319e; WORD $0x06997b05 // .quad 475546501309804958 + WORD $0xe9d0696a; WORD $0xdb2e51bf // .quad -2653093245771290262 + WORD $0xbdf81f03; WORD $0x441fece3 // .quad 4908902581746016003 + WORD $0xf22241e2; WORD $0x88fcf317 // .quad -8575712306248138270 + WORD $0xad7626c3; WORD $0xd527e81c // .quad -3087243809672255805 + WORD $0xeeaad25a; WORD $0xab3c2fdd // .quad -6107954364382784934 + WORD $0xd8d3b074; WORD $0x8a71e223 // .quad -8470740780517707660 + WORD $0x6a5586f1; WORD $0xd60b3bd5 // .quad -3023256937051093263 + WORD $0x67844e49; WORD $0xf6872d56 // .quad -682526969396179383 + WORD $0x62757456; WORD $0x85c70565 // .quad -8807064613298015146 + WORD $0x016561db; WORD $0xb428f8ac // .quad -5464844730172612133 + WORD $0xbb12d16c; WORD $0xa738c6be // .quad -6397144748195131028 + WORD $0x01beba52; WORD $0xe13336d7 // .quad -2219369894288377262 + WORD $0x69d785c7; WORD $0xd106f86e // .quad -3384744916816525881 + WORD $0x61173473; WORD $0xecc00246 // .quad -1387106183930235789 + WORD $0x0226b39c; WORD $0x82a45b45 // .quad -9032994600651410532 + WORD $0xf95d0190; WORD $0x27f002d7 // .quad 2877803288514593168 + WORD $0x42b06084; WORD $0xa34d7216 // .quad -6679557232386875260 + WORD $0xf7b441f4; WORD $0x31ec038d // .quad 3597254110643241460 + WORD $0xd35c78a5; WORD $0xcc20ce9b // .quad -3737760522056206171 + WORD $0x75a15271; WORD $0x7e670471 // .quad 9108253656731439729 + WORD $0xc83396ce; WORD $0xff290242 // .quad -60514634142869810 + WORD $0xe984d386; WORD $0x0f0062c6 // .quad 1080972517029761926 + WORD $0xbd203e41; WORD $0x9f79a169 // .quad -6955350673980375487 + WORD $0xa3e60868; WORD $0x52c07b78 // .quad 5962901664714590312 + WORD $0x2c684dd1; WORD $0xc75809c4 // .quad -4082502324048081455 + WORD $0xccdf8a82; WORD $0xa7709a56 // .quad -6381430974388925822 + WORD $0x37826145; WORD $0xf92e0c35 // .quad -491441886632713915 + WORD $0x400bb691; WORD $0x88a66076 // .quad -8600080377420466543 + WORD $0x42b17ccb; WORD $0x9bbcc7a1 // .quad -7224680206786528053 + WORD $0xd00ea435; WORD $0x6acff893 // .quad 7696643601933968437 + WORD $0x935ddbfe; WORD $0xc2abf989 // .quad -4419164240055772162 + WORD $0xc4124d43; WORD $0x0583f6b8 // .quad 397432465562684739 + WORD $0xf83552fe; WORD $0xf356f7eb // .quad -912269281642327298 + WORD $0x7a8b704a; WORD $0xc3727a33 // .quad -4363290727450709942 + WORD $0x7b2153de; WORD $0x98165af3 // .quad -7487697328667536418 + WORD $0x592e4c5c; WORD $0x744f18c0 // .quad 8380944645968776284 + WORD $0x59e9a8d6; WORD $0xbe1bf1b0 // .quad -4747935642407032618 + WORD $0x6f79df73; WORD $0x1162def0 // .quad 1252808770606194547 + WORD $0x7064130c; WORD $0xeda2ee1c // .quad -1323233534581402868 + WORD $0x45ac2ba8; WORD $0x8addcb56 // .quad -8440366555225904216 + WORD $0xc63e8be7; WORD $0x9485d4d1 // .quad -7744549986754458649 + WORD $0xd7173692; WORD $0x6d953e2b // .quad 7896285879677171346 + WORD $0x37ce2ee1; WORD $0xb9a74a06 // .quad -5069001465015685407 + WORD $0xccdd0437; WORD $0xc8fa8db6 // .quad -3964700705685699529 + WORD $0xc5c1ba99; WORD $0xe8111c87 // .quad -1724565812842218855 + WORD $0x400a22a2; WORD $0x1d9c9892 // .quad 2133748077373825698 + WORD $0xdb9914a0; WORD $0x910ab1d4 // .quad -7995382660667468640 + WORD $0xd00cab4b; WORD $0x2503beb6 // .quad 2667185096717282123 + WORD $0x127f59c8; WORD $0xb54d5e4a // .quad -5382542307406947896 + WORD $0x840fd61d; WORD $0x2e44ae64 // .quad 3333981370896602653 + WORD $0x971f303a; WORD $0xe2a0b5dc // .quad -2116491865831296966 + WORD $0xd289e5d2; WORD $0x5ceaecfe // .quad 6695424375237764562 + WORD $0xde737e24; WORD $0x8da471a9 // .quad -8240336443785642460 + WORD $0x872c5f47; WORD $0x7425a83e // .quad 8369280469047205703 + WORD $0x56105dad; WORD $0xb10d8e14 // .quad -5688734536304665171 + WORD $0x28f77719; WORD $0xd12f124e // .quad -3373457468973156583 + WORD $0x6b947518; WORD $0xdd50f199 // .quad -2499232151953443560 + WORD $0xd99aaa6f; WORD $0x82bd6b70 // .quad -9025939945749304721 + WORD $0xe33cc92f; WORD $0x8a5296ff // .quad -8479549122611984081 + WORD $0x1001550b; WORD $0x636cc64d // .quad 7164319141522920715 + WORD $0xdc0bfb7b; WORD $0xace73cbf // .quad -5987750384837592197 + WORD $0x5401aa4e; WORD $0x3c47f7e0 // .quad 4343712908476262990 + WORD $0xd30efa5a; WORD $0xd8210bef // .quad -2873001962619602342 + WORD $0x34810a71; WORD $0x65acfaec // .quad 7326506586225052273 + WORD $0xe3e95c78; WORD $0x8714a775 // .quad -8713155254278333320 + WORD $0x41a14d0d; WORD $0x7f1839a7 // .quad 9158133232781315341 + WORD $0x5ce3b396; WORD $0xa8d9d153 // .quad -6279758049420528746 + WORD $0x1209a050; WORD $0x1ede4811 // .quad 2224294504121868368 + WORD $0x341ca07c; WORD $0xd31045a8 // .quad -3238011543348273028 + WORD $0xab460432; WORD $0x934aed0a // .quad -7833187971778608078 + WORD $0x2091e44d; WORD $0x83ea2b89 // .quad -8941286242233752499 + WORD $0x5617853f; WORD $0xf81da84d // .quad -568112927868484289 + WORD $0x68b65d60; WORD $0xa4e4b66b // .quad -6564921784364802720 + WORD $0xab9d668e; WORD $0x36251260 // .quad 3901544858591782542 + WORD $0x42e3f4b9; WORD $0xce1de406 // .quad -3594466212028615495 + WORD $0x6b426019; WORD $0xc1d72b7c // .quad -4479063491021217767 + WORD $0xe9ce78f3; WORD $0x80d2ae83 // .quad -9164070410158966541 + WORD $0x8612f81f; WORD $0xb24cf65b // .quad -5598829363776522209 + WORD $0xe4421730; WORD $0xa1075a24 // .quad -6843401994271320272 + WORD $0x6797b627; WORD $0xdee033f2 // .quad -2386850686293264857 + WORD $0x1d529cfc; WORD $0xc94930ae // .quad -3942566474411762436 + WORD $0x017da3b1; WORD $0x169840ef // .quad 1628122660560806833 + WORD $0xa4a7443c; WORD $0xfb9b7cd9 // .quad -316522074587315140 + WORD $0x60ee864e; WORD $0x8e1f2895 // .quad -8205795374004271538 + WORD $0x06e88aa5; WORD $0x9d412e08 // .quad -7115355324258153819 + WORD $0xb92a27e2; WORD $0xf1a6f2ba // .quad -1033872180650563614 + WORD $0x08a2ad4e; WORD $0xc491798a // .quad -4282508136895304370 + WORD $0x6774b1db; WORD $0xae10af69 // .quad -5904026244240592421 + WORD $0x8acb58a2; WORD $0xf5b5d7ec // .quad -741449152691742558 + WORD $0xe0a8ef29; WORD $0xacca6da1 // .quad -5995859411864064215 + WORD $0xd6bf1765; WORD $0x9991a6f3 // .quad -7380934748073420955 + WORD $0x58d32af3; WORD $0x17fd090a // .quad 1728547772024695539 + WORD $0xcc6edd3f; WORD $0xbff610b0 // .quad -4614482416664388289 + WORD $0xef07f5b0; WORD $0xddfc4b4c // .quad -2451001303396518480 + WORD $0xff8a948e; WORD $0xeff394dc // .quad -1156417002403097458 + WORD $0x1564f98e; WORD $0x4abdaf10 // .quad 5385653213018257806 + WORD $0x1fb69cd9; WORD $0x95f83d0a // .quad -7640289654143017767 + WORD $0x1abe37f1; WORD $0x9d6d1ad4 // .quad -7102991539009341455 + WORD $0xa7a4440f; WORD $0xbb764c4c // .quad -4938676049251384305 + WORD $0x216dc5ed; WORD $0x84c86189 // .quad -8878739423761676819 + WORD $0xd18d5513; WORD $0xea53df5f // .quad -1561659043136842477 + WORD $0xb4e49bb4; WORD $0x32fd3cf5 // .quad 3674159897003727796 + WORD $0xe2f8552c; WORD $0x92746b9b // .quad -7893565929601608404 + WORD $0x221dc2a1; WORD $0x3fbc8c33 // .quad 4592699871254659745 + WORD $0xdbb66a77; WORD $0xb7118682 // .quad -5255271393574622601 + WORD $0xeaa5334a; WORD $0x0fabaf3f // .quad 1129188820640936778 + WORD $0x92a40515; WORD $0xe4d5e823 // .quad -1957403223540890347 + WORD $0xf2a7400e; WORD $0x29cb4d87 // .quad 3011586022114279438 + WORD $0x3ba6832d; WORD $0x8f05b116 // .quad -8140906042354138323 + WORD $0xef511012; WORD $0x743e20e9 // .quad 8376168546070237202 + WORD $0xca9023f8; WORD $0xb2c71d5b // .quad -5564446534515285000 + WORD $0x6b255416; WORD $0x914da924 // .quad -7976533391121755114 + WORD $0xbd342cf6; WORD $0xdf78e4b2 // .quad -2343872149716718346 + WORD $0xc2f7548e; WORD $0x1ad089b6 // .quad 1932195658189984910 + WORD $0xb6409c1a; WORD $0x8bab8eef // .quad -8382449121214030822 + WORD $0x73b529b1; WORD $0xa184ac24 // .quad -6808127464117294671 + WORD $0xa3d0c320; WORD $0xae9672ab // .quad -5866375383090150624 + WORD $0x90a2741e; WORD $0xc9e5d72d // .quad -3898473311719230434 + WORD $0x8cc4f3e8; WORD $0xda3c0f56 // .quad -2721283210435300376 + WORD $0x7a658892; WORD $0x7e2fa67c // .quad 9092669226243950738 + WORD $0x17fb1871; WORD $0x88658996 // .quad -8618331034163144591 + WORD $0x98feeab7; WORD $0xddbb901b // .quad -2469221522477225289 + WORD $0x9df9de8d; WORD $0xaa7eebfb // .quad -6161227774276542835 + WORD $0x7f3ea565; WORD $0x552a7422 // .quad 6136845133758244197 + WORD $0x85785631; WORD $0xd51ea6fa // .quad -3089848699418290639 + WORD $0x8f87275f; WORD $0xd53a8895 // .quad -3082000819042179233 + WORD $0x936b35de; WORD $0x8533285c // .quad -8848684464777513506 + WORD $0xf368f137; WORD $0x8a892aba // .quad -8464187042230111945 + WORD $0xb8460356; WORD $0xa67ff273 // .quad -6449169562544503978 + WORD $0xb0432d85; WORD $0x2d2b7569 // .quad 3254824252494523781 + WORD $0xa657842c; WORD $0xd01fef10 // .quad -3449775934753242068 + WORD $0x0e29fc73; WORD $0x9c3b2962 // .quad -7189106879045698445 + WORD $0x67f6b29b; WORD $0x8213f56a // .quad -9073638986861858149 + WORD $0x91b47b8f; WORD $0x8349f3ba // .quad -8986383598807123057 + WORD $0x01f45f42; WORD $0xa298f2c5 // .quad -6730362715149934782 + WORD $0x36219a73; WORD $0x241c70a9 // .quad 2602078556773259891 + WORD $0x42717713; WORD $0xcb3f2f76 // .quad -3801267375510030573 + WORD $0x83aa0110; WORD $0xed238cd3 // .quad -1359087822460813040 + WORD $0xd30dd4d7; WORD $0xfe0efb53 // .quad -139898200960150313 + WORD $0x324a40aa; WORD $0xf4363804 // .quad -849429889038008150 + WORD $0x63e8a506; WORD $0x9ec95d14 // .quad -7004965403241175802 + WORD $0x3edcd0d5; WORD $0xb143c605 // .quad -5673473379724898091 + WORD $0x7ce2ce48; WORD $0xc67bb459 // .quad -4144520735624081848 + WORD $0x8e94050a; WORD $0xdd94b786 // .quad -2480155706228734710 + WORD $0xdc1b81da; WORD $0xf81aa16f // .quad -568964901102714406 + WORD $0x191c8326; WORD $0xca7cf2b4 // .quad -3855940325606653146 + WORD $0xe9913128; WORD $0x9b10a4e5 // .quad -7273132090830278360 + WORD $0x1f63a3f0; WORD $0xfd1c2f61 // .quad -208239388580928528 + WORD $0x63f57d72; WORD $0xc1d4ce1f // .quad -4479729095110460046 + WORD $0x673c8cec; WORD $0xbc633b39 // .quad -4871985254153548564 + WORD $0x3cf2dccf; WORD $0xf24a01a7 // .quad -987975350460687153 + WORD $0xe085d813; WORD $0xd5be0503 // .quad -3044990783845967853 + WORD $0x8617ca01; WORD $0x976e4108 // .quad -7535013621679011327 + WORD $0xd8a74e18; WORD $0x4b2d8644 // .quad 5417133557047315992 + WORD $0xa79dbc82; WORD $0xbd49d14a // .quad -4807081008671376254 + WORD $0x0ed1219e; WORD $0xddf8e7d6 // .quad -2451955090545630818 + WORD $0x51852ba2; WORD $0xec9c459d // .quad -1397165242411832414 + WORD $0xc942b503; WORD $0xcabb90e5 // .quad -3838314940804713213 + WORD $0x52f33b45; WORD $0x93e1ab82 // .quad -7790757304148477115 + WORD $0x3b936243; WORD $0x3d6a751f // .quad 4425478360848884291 + WORD $0xe7b00a17; WORD $0xb8da1662 // .quad -5126760611758208489 + WORD $0x0a783ad4; WORD $0x0cc51267 // .quad 920161932633717460 + WORD $0xa19c0c9d; WORD $0xe7109bfb // .quad -1796764746270372707 + WORD $0x668b24c5; WORD $0x27fb2b80 // .quad 2880944217109767365 + WORD $0x450187e2; WORD $0x906a617d // .quad -8040506994060064798 + WORD $0x802dedf6; WORD $0xb1f9f660 // .quad -5622191765467566602 + WORD $0x9641e9da; WORD $0xb484f9dc // .quad -5438947724147693094 + WORD $0xa0396973; WORD $0x5e7873f8 // .quad 6807318348447705459 + WORD $0xbbd26451; WORD $0xe1a63853 // .quad -2186998636757228463 + WORD $0x6423e1e8; WORD $0xdb0b487b // .quad -2662955059861265944 + WORD $0x55637eb2; WORD $0x8d07e334 // .quad -8284403175614349646 + WORD $0x3d2cda62; WORD $0x91ce1a9a // .quad -7940379843253970334 + WORD $0x6abc5e5f; WORD $0xb049dc01 // .quad -5743817951090549153 + WORD $0xcc7810fb; WORD $0x7641a140 // .quad 8521269269642088699 + WORD $0xc56b75f7; WORD $0xdc5c5301 // .quad -2568086420435798537 + WORD $0x7fcb0a9d; WORD $0xa9e904c8 // .quad -6203421752542164323 + WORD $0x1b6329ba; WORD $0x89b9b3e1 // .quad -8522583040413455942 + WORD $0x9fbdcd44; WORD $0x546345fa // .quad 6080780864604458308 + WORD $0x623bf429; WORD $0xac2820d9 // .quad -6041542782089432023 + WORD $0x47ad4095; WORD $0xa97c1779 // .quad -6234081974526590827 + WORD $0xbacaf133; WORD $0xd732290f // .quad -2940242459184402125 + WORD $0xcccc485d; WORD $0x49ed8eab // .quad 5327070802775656541 + WORD $0xd4bed6c0; WORD $0x867f59a9 // .quad -8755180564631333184 + WORD $0xbfff5a74; WORD $0x5c68f256 // .quad 6658838503469570676 + WORD $0x49ee8c70; WORD $0xa81f3014 // .quad -6332289687361778576 + WORD $0x6fff3111; WORD $0x73832eec // .quad 8323548129336963345 + WORD $0x5c6a2f8c; WORD $0xd226fc19 // .quad -3303676090774835316 + WORD $0xc5ff7eab; WORD $0xc831fd53 // .quad -4021154456019173717 + WORD $0xd9c25db7; WORD $0x83585d8f // .quad -8982326584375353929 + WORD $0xb77f5e55; WORD $0xba3e7ca8 // .quad -5026443070023967147 + WORD $0xd032f525; WORD $0xa42e74f3 // .quad -6616222212041804507 + WORD $0xe55f35eb; WORD $0x28ce1bd2 // .quad 2940318199324816875 + WORD $0xc43fb26f; WORD $0xcd3a1230 // .quad -3658591746624867729 + WORD $0xcf5b81b3; WORD $0x7980d163 // .quad 8755227902219092403 + WORD $0x7aa7cf85; WORD $0x80444b5e // .quad -9204148869281624187 + WORD $0xc332621f; WORD $0xd7e105bc // .quad -2891023177508298209 + WORD $0x1951c366; WORD $0xa0555e36 // .quad -6893500068174642330 + WORD $0xf3fefaa7; WORD $0x8dd9472b // .quad -8225464990312760665 + WORD $0x9fa63440; WORD $0xc86ab5c3 // .quad -4005189066790915008 + WORD $0xf0feb951; WORD $0xb14f98f6 // .quad -5670145219463562927 + WORD $0x878fc150; WORD $0xfa856334 // .quad -394800315061255856 + WORD $0x569f33d3; WORD $0x6ed1bf9a // .quad 7985374283903742931 + WORD $0xd4b9d8d2; WORD $0x9c935e00 // .quad -7164279224554366766 + WORD $0xec4700c8; WORD $0x0a862f80 // .quad 758345818024902856 + WORD $0x09e84f07; WORD $0xc3b83581 // .quad -4343663012265570553 + WORD $0x2758c0fa; WORD $0xcd27bb61 // .quad -3663753745896259334 + WORD $0x4c6262c8; WORD $0xf4a642e1 // .quad -817892746904575288 + WORD $0xb897789c; WORD $0x8038d51c // .quad -9207375118826243940 + WORD $0xcfbd7dbd; WORD $0x98e7e9cc // .quad -7428711994456441411 + WORD $0xe6bd56c3; WORD $0xe0470a63 // .quad -2285846861678029117 + WORD $0x03acdd2c; WORD $0xbf21e440 // .quad -4674203974643163860 + WORD $0xe06cac74; WORD $0x1858ccfc // .quad 1754377441329851508 + WORD $0x04981478; WORD $0xeeea5d50 // .quad -1231068949876566920 + WORD $0x0c43ebc8; WORD $0x0f37801e // .quad 1096485900831157192 + WORD $0x02df0ccb; WORD $0x95527a52 // .quad -7686947121313936181 + WORD $0x8f54e6ba; WORD $0xd3056025 // .quad -3241078642388441414 + WORD $0x8396cffd; WORD $0xbaa718e6 // .quad -4996997883215032323 + WORD $0xf32a2069; WORD $0x47c6b82e // .quad 5172023733869224041 + WORD $0x247c83fd; WORD $0xe950df20 // .quad -1634561335591402499 + WORD $0x57fa5441; WORD $0x4cdc331d // .quad 5538357842881958977 + WORD $0x16cdd27e; WORD $0x91d28b74 // .quad -7939129862385708418 + WORD $0xadf8e952; WORD $0xe0133fe4 // .quad -2300424733252327086 + WORD $0x1c81471d; WORD $0xb6472e51 // .quad -5312226309554747619 + WORD $0xd97723a6; WORD $0x58180fdd // .quad 6347841120289366950 + WORD $0x63a198e5; WORD $0xe3d8f9e5 // .quad -2028596868516046619 + WORD $0xa7ea7648; WORD $0x570f09ea // .quad 6273243709394548296 + WORD $0x5e44ff8f; WORD $0x8e679c2f // .quad -8185402070463610993 + WORD $0x51e513da; WORD $0x2cd2cc65 // .quad 3229868618315797466 + WORD $0x35d63f73; WORD $0xb201833b // .quad -5620066569652125837 + WORD $0xa65e58d1; WORD $0xf8077f7e // .quad -574350245532641071 + WORD $0x034bcf4f; WORD $0xde81e40a // .quad -2413397193637769393 + WORD $0x27faf782; WORD $0xfb04afaf // .quad -358968903457900670 + WORD $0x420f6191; WORD $0x8b112e86 // .quad -8425902273664687727 + WORD $0xf1f9b563; WORD $0x79c5db9a // .quad 8774660907532399971 + WORD $0xd29339f6; WORD $0xadd57a27 // .quad -5920691823653471754 + WORD $0xae7822bc; WORD $0x18375281 // .quad 1744954097560724156 + WORD $0xc7380874; WORD $0xd94ad8b1 // .quad -2789178761139451788 + WORD $0x0d0b15b5; WORD $0x8f229391 // .quad -8132775725879323211 + WORD $0x1c830548; WORD $0x87cec76f // .quad -8660765753353239224 + WORD $0x504ddb22; WORD $0xb2eb3875 // .quad -5554283638921766110 + WORD $0xe3a3c69a; WORD $0xa9c2794a // .quad -6214271173264161126 + WORD $0xa46151eb; WORD $0x5fa60692 // .quad 6892203506629956075 + WORD $0x9c8cb841; WORD $0xd433179d // .quad -3156152948152813503 + WORD $0xa6bcd333; WORD $0xdbc7c41b // .quad -2609901835997359309 + WORD $0x81d7f328; WORD $0x849feec2 // .quad -8890124620236590296 + WORD $0x906c0800; WORD $0x12b9b522 // .quad 1349308723430688768 + WORD $0x224deff3; WORD $0xa5c7ea73 // .quad -6500969756868349965 + WORD $0x34870a00; WORD $0xd768226b // .quad -2925050114139026944 + WORD $0xeae16bef; WORD $0xcf39e50f // .quad -3514526177658049553 + WORD $0x00d46640; WORD $0xe6a11583 // .quad -1828156321336891840 + WORD $0xf2cce375; WORD $0x81842f29 // .quad -9114107888677362827 + WORD $0xc1097fd0; WORD $0x60495ae3 // .quad 6938176635183661008 + WORD $0x6f801c53; WORD $0xa1e53af4 // .quad -6780948842419315629 + WORD $0xb14bdfc4; WORD $0x385bb19c // .quad 4061034775552188356 + WORD $0x8b602368; WORD $0xca5e89b1 // .quad -3864500034596756632 + WORD $0xdd9ed7b5; WORD $0x46729e03 // .quad 5076293469440235445 + WORD $0xee382c42; WORD $0xfcf62c1d // .quad -218939024818557886 + WORD $0x6a8346d1; WORD $0x6c07a2c2 // .quad 7784369436827535057 + WORD $0xb4e31ba9; WORD $0x9e19db92 // .quad -7054365918152680535 + WORD $0x05241885; WORD $0xc7098b73 // .quad -4104596259247744891 + WORD $0x621be293; WORD $0xc5a05277 // .quad -4206271379263462765 + WORD $0xc66d1ea7; WORD $0xb8cbee4f // .quad -5130745324059681113 + WORD $0x3aa2db38; WORD $0xf7086715 // .quad -646153205651940552 + WORD $0xdc043328; WORD $0x737f74f1 // .quad 8322499218531169064 + WORD $0x44a5c903; WORD $0x9a65406d // .quad -7321374781173544701 + WORD $0x53053ff2; WORD $0x505f522e // .quad 5791438004736573426 + WORD $0x95cf3b44; WORD $0xc0fe9088 // .quad -4540032458039542972 + WORD $0xe7c68fef; WORD $0x647726b9 // .quad 7239297505920716783 + WORD $0xbb430a15; WORD $0xf13e34aa // .quad -1063354554122040811 + WORD $0x30dc19f5; WORD $0x5eca7834 // .quad 6830403950414141941 + WORD $0xb509e64d; WORD $0x96c6e0ea // .quad -7582125623967357363 + WORD $0x3d132072; WORD $0xb67d1641 // .quad -5297053117264486286 + WORD $0x624c5fe0; WORD $0xbc789925 // .quad -4865971011531808800 + WORD $0x8c57e88f; WORD $0xe41c5bd1 // .quad -2009630378153219953 + WORD $0xbadf77d8; WORD $0xeb96bf6e // .quad -1470777745987373096 + WORD $0xf7b6f159; WORD $0x8e91b962 // .quad -8173548013986844327 + WORD $0x34cbaae7; WORD $0x933e37a5 // .quad -7836765118883190041 + WORD $0xb5a4adb0; WORD $0x723627bb // .quad 8229809056225996208 + WORD $0x81fe95a1; WORD $0xb80dc58e // .quad -5184270380176599647 + WORD $0xa30dd91c; WORD $0xcec3b1aa // .quad -3547796734999668452 + WORD $0x227e3b09; WORD $0xe61136f2 // .quad -1868651956793361655 + WORD $0xa5e8a7b1; WORD $0x213a4f0a // .quad 2394313059052595121 + WORD $0x558ee4e6; WORD $0x8fcac257 // .quad -8085436500636932890 + WORD $0x4f62d19d; WORD $0xa988e2cd // .quad -6230480713039031907 + WORD $0x2af29e1f; WORD $0xb3bd72ed // .quad -5495109607368778209 + WORD $0xa33b8605; WORD $0x93eb1b80 // .quad -7788100891298789883 + WORD $0x75af45a7; WORD $0xe0accfa8 // .quad -2257200990783584857 + WORD $0x660533c3; WORD $0xbc72f130 // .quad -4867563057061743677 + WORD $0x498d8b88; WORD $0x8c6c01c9 // .quad -8328279646880822392 + WORD $0x7f8680b4; WORD $0xeb8fad7c // .quad -1472767802899791692 + WORD $0x9bf0ee6a; WORD $0xaf87023b // .quad -5798663540173640086 + WORD $0x9f6820e1; WORD $0xa67398db // .quad -6452645772052127519 + WORD $0x82ed2a05; WORD $0xdb68c2ca // .quad -2636643406789662203 + WORD $0x43a1148c; WORD $0x88083f89 // .quad -8644589625959967604 + WORD $0x91d43a43; WORD $0x892179be // .quad -8565431156884620733 + WORD $0x948959b0; WORD $0x6a0a4f6b // .quad 7641007041259592112 + WORD $0x364948d4; WORD $0xab69d82e // .quad -6095102927678388012 + WORD $0x79abb01c; WORD $0x848ce346 // .quad -8895485272135061476 + WORD $0xc3db9b09; WORD $0xd6444e39 // .quad -3007192641170597111 + WORD $0x0c0b4e11; WORD $0xf2d80e0c // .quad -947992276657025519 + WORD $0x1a6940e5; WORD $0x85eab0e4 // .quad -8797024428372705051 + WORD $0x0f0e2195; WORD $0x6f8e118f // .quad 8038381691033493909 + WORD $0x2103911f; WORD $0xa7655d1d // .quad -6384594517038493409 + WORD $0xd2d1a9fb; WORD $0x4b7195f2 // .quad 5436291095364479483 + WORD $0x69447567; WORD $0xd13eb464 // .quad -3369057127870728857 + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + // .p2align 2, 0x00 +_POW_TAB: + WORD $0x00000001 // .long 1 + WORD $0x00000003 // .long 3 + WORD $0x00000006 // .long 6 + WORD $0x00000009 // .long 9 + WORD $0x0000000d // .long 13 + WORD $0x00000010 // .long 16 + WORD $0x00000013 // .long 19 + WORD $0x00000017 // .long 23 + WORD $0x0000001a // .long 26 + // .p2align 2, 0x00 +_LSHIFT_TAB: + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000001 // .long 1 + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000001 // .long 1 + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000001 // .long 1 + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000002 // .long 2 + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000002 // .long 2 + WORD $0x35323133 // .asciz 4, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000002 // .long 2 + WORD $0x32363531 // .asciz 4, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000003 // .long 3 + WORD $0x32313837 // .asciz 4, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000003 // .long 3 + WORD $0x36303933 // .asciz 4, '390625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000003 // .long 3 + WORD $0x33353931 // .asciz 4, '1953125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000004 // .long 4 + WORD $0x35363739 // .asciz 4, '9765625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000004 // .long 4 + WORD $0x32383834 // .asciz 4, '48828125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323138 // .asciz 4, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000004 // .long 4 + WORD $0x31343432 // .asciz 4, '244140625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363034 // .asciz 4, '40625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000004 // .long 4 + WORD $0x30323231 // .asciz 4, '1220703125\x00\x00\x00\x00\x00\x00' + WORD $0x31333037 // .asciz 4, '703125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000005 // .long 5 + WORD $0x33303136 // .asciz 4, '6103515625\x00\x00\x00\x00\x00\x00' + WORD $0x36353135 // .asciz 4, '515625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000005 // .long 5 + WORD $0x31353033 // .asciz 4, '30517578125\x00\x00\x00\x00\x00' + WORD $0x38373537 // .asciz 4, '7578125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000005 // .long 5 + WORD $0x35323531 // .asciz 4, '152587890625\x00\x00\x00\x00' + WORD $0x39383738 // .asciz 4, '87890625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323630 // .asciz 4, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000006 // .long 6 + WORD $0x39323637 // .asciz 4, '762939453125\x00\x00\x00\x00' + WORD $0x35343933 // .asciz 4, '39453125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323133 // .asciz 4, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000006 // .long 6 + WORD $0x34313833 // .asciz 4, '3814697265625\x00\x00\x00' + WORD $0x32373936 // .asciz 4, '697265625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363536 // .asciz 4, '65625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000006 // .long 6 + WORD $0x37303931 // .asciz 4, '19073486328125\x00\x00' + WORD $0x36383433 // .asciz 4, '3486328125\x00\x00\x00\x00\x00\x00' + WORD $0x31383233 // .asciz 4, '328125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000007 // .long 7 + WORD $0x36333539 // .asciz 4, '95367431640625\x00\x00' + WORD $0x31333437 // .asciz 4, '7431640625\x00\x00\x00\x00\x00\x00' + WORD $0x36303436 // .asciz 4, '640625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000007 // .long 7 + WORD $0x38363734 // .asciz 4, '476837158203125\x00' + WORD $0x35313733 // .asciz 4, '37158203125\x00\x00\x00\x00\x00' + WORD $0x33303238 // .asciz 4, '8203125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000007 // .long 7 + WORD $0x34383332 // .asciz 4, '2384185791015625' + WORD $0x37353831 // .asciz 4, '185791015625\x00\x00\x00\x00' + WORD $0x31303139 // .asciz 4, '91015625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323635 // .asciz 4, '5625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000007 // .long 7 + WORD $0x32393131 // .asciz 4, '1192092895507812' + WORD $0x38323930 // .asciz 4, '0928955078125\x00\x00\x00' + WORD $0x30353539 // .asciz 4, '955078125\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32313837 // .asciz 4, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000008 // .long 8 + WORD $0x30363935 // .asciz 4, '5960464477539062' + WORD $0x34343634 // .asciz 4, '4644775390625\x00\x00\x00' + WORD $0x33353737 // .asciz 4, '775390625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363039 // .asciz 4, '90625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000008 // .long 8 + WORD $0x30383932 // .asciz 4, '2980232238769531' + WORD $0x32323332 // .asciz 4, '23223876953125\x00\x00' + WORD $0x36373833 // .asciz 4, '3876953125\x00\x00\x00\x00\x00\x00' + WORD $0x31333539 // .asciz 4, '953125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000008 // .long 8 + WORD $0x30393431 // .asciz 4, '1490116119384765' + WORD $0x31363131 // .asciz 4, '116119384765625\x00' + WORD $0x38333931 // .asciz 4, '19384765625\x00\x00\x00\x00\x00' + WORD $0x35363734 // .asciz 4, '4765625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000009 // .long 9 + WORD $0x30353437 // .asciz 4, '7450580596923828' + WORD $0x35303835 // .asciz 4, '580596923828125\x00' + WORD $0x32393639 // .asciz 4, '96923828125\x00\x00\x00\x00\x00' + WORD $0x38323833 // .asciz 4, '3828125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000009 // .long 9 + WORD $0x35323733 // .asciz 4, '3725290298461914' + WORD $0x32303932 // .asciz 4, '2902984619140625' + WORD $0x36343839 // .asciz 4, '984619140625\x00\x00\x00\x00' + WORD $0x34313931 // .asciz 4, '19140625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323630 // .asciz 4, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000009 // .long 9 + WORD $0x32363831 // .asciz 4, '1862645149230957' + WORD $0x31353436 // .asciz 4, '6451492309570312' + WORD $0x33323934 // .asciz 4, '4923095703125\x00\x00\x00' + WORD $0x37353930 // .asciz 4, '095703125\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32313330 // .asciz 4, '03125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000a // .long 10 + WORD $0x33313339 // .asciz 4, '9313225746154785' + WORD $0x37353232 // .asciz 4, '2257461547851562' + WORD $0x35313634 // .asciz 4, '4615478515625\x00\x00\x00' + WORD $0x35383734 // .asciz 4, '478515625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363531 // .asciz 4, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000a // .long 10 + WORD $0x36353634 // .asciz 4, '4656612873077392' + WORD $0x38323136 // .asciz 4, '6128730773925781' + WORD $0x37303337 // .asciz 4, '73077392578125\x00\x00' + WORD $0x32393337 // .asciz 4, '7392578125\x00\x00\x00\x00\x00\x00' + WORD $0x31383735 // .asciz 4, '578125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000a // .long 10 + WORD $0x38323332 // .asciz 4, '2328306436538696' + WORD $0x34363033 // .asciz 4, '3064365386962890' + WORD $0x33353633 // .asciz 4, '365386962890625\x00' + WORD $0x36393638 // .asciz 4, '86962890625\x00\x00\x00\x00\x00' + WORD $0x30393832 // .asciz 4, '2890625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000a // .long 10 + WORD $0x34363131 // .asciz 4, '1164153218269348' + WORD $0x32333531 // .asciz 4, '1532182693481445' + WORD $0x36323831 // .asciz 4, '1826934814453125' + WORD $0x38343339 // .asciz 4, '934814453125\x00\x00\x00\x00' + WORD $0x35343431 // .asciz 4, '14453125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323133 // .asciz 4, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000b // .long 11 + WORD $0x30323835 // .asciz 4, '5820766091346740' + WORD $0x30363637 // .asciz 4, '7660913467407226' + WORD $0x34333139 // .asciz 4, '9134674072265625' + WORD $0x30343736 // .asciz 4, '674072265625\x00\x00\x00\x00' + WORD $0x36323237 // .asciz 4, '72265625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323635 // .asciz 4, '5625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000b // .long 11 + WORD $0x30313932 // .asciz 4, '2910383045673370' + WORD $0x30333833 // .asciz 4, '3830456733703613' + WORD $0x37363534 // .asciz 4, '4567337036132812' + WORD $0x30373333 // .asciz 4, '3370361328125\x00\x00\x00' + WORD $0x33313633 // .asciz 4, '361328125\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32313832 // .asciz 4, '28125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000b // .long 11 + WORD $0x35353431 // .asciz 4, '1455191522836685' + WORD $0x35313931 // .asciz 4, '1915228366851806' + WORD $0x33383232 // .asciz 4, '2283668518066406' + WORD $0x35383636 // .asciz 4, '66851806640625\x00\x00' + WORD $0x36303831 // .asciz 4, '1806640625\x00\x00\x00\x00\x00\x00' + WORD $0x36303436 // .asciz 4, '640625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000c // .long 12 + WORD $0x35373237 // .asciz 4, '7275957614183425' + WORD $0x36373539 // .asciz 4, '9576141834259033' + WORD $0x38313431 // .asciz 4, '1418342590332031' + WORD $0x35323433 // .asciz 4, '34259033203125\x00\x00' + WORD $0x33333039 // .asciz 4, '9033203125\x00\x00\x00\x00\x00\x00' + WORD $0x31333032 // .asciz 4, '203125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000c // .long 12 + WORD $0x37333633 // .asciz 4, '3637978807091712' + WORD $0x38383739 // .asciz 4, '9788070917129516' + WORD $0x39303730 // .asciz 4, '0709171295166015' + WORD $0x32313731 // .asciz 4, '171295166015625\x00' + WORD $0x36313539 // .asciz 4, '95166015625\x00\x00\x00\x00\x00' + WORD $0x35313036 // .asciz 4, '6015625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000c // .long 12 + WORD $0x38313831 // .asciz 4, '1818989403545856' + WORD $0x34393839 // .asciz 4, '9894035458564758' + WORD $0x34353330 // .asciz 4, '0354585647583007' + WORD $0x36353835 // .asciz 4, '5856475830078125' + WORD $0x38353734 // .asciz 4, '475830078125\x00\x00\x00\x00' + WORD $0x37303033 // .asciz 4, '30078125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323138 // .asciz 4, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000d // .long 13 + WORD $0x34393039 // .asciz 4, '9094947017729282' + WORD $0x30373439 // .asciz 4, '9470177292823791' + WORD $0x32373731 // .asciz 4, '1772928237915039' + WORD $0x32383239 // .asciz 4, '9282379150390625' + WORD $0x31393733 // .asciz 4, '379150390625\x00\x00\x00\x00' + WORD $0x39333035 // .asciz 4, '50390625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323630 // .asciz 4, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000d // .long 13 + WORD $0x37343534 // .asciz 4, '4547473508864641' + WORD $0x35333734 // .asciz 4, '4735088646411895' + WORD $0x36383830 // .asciz 4, '0886464118957519' + WORD $0x31343634 // .asciz 4, '4641189575195312' + WORD $0x35393831 // .asciz 4, '1895751953125\x00\x00\x00' + WORD $0x39313537 // .asciz 4, '751953125\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32313335 // .asciz 4, '53125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000d // .long 13 + WORD $0x33373232 // .asciz 4, '2273736754432320' + WORD $0x37363337 // .asciz 4, '7367544323205947' + WORD $0x33343435 // .asciz 4, '5443232059478759' + WORD $0x30323332 // .asciz 4, '2320594787597656' + WORD $0x37343935 // .asciz 4, '59478759765625\x00\x00' + WORD $0x39353738 // .asciz 4, '8759765625\x00\x00\x00\x00\x00\x00' + WORD $0x36353637 // .asciz 4, '765625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000d // .long 13 + WORD $0x36333131 // .asciz 4, '1136868377216160' + WORD $0x33383638 // .asciz 4, '8683772161602973' + WORD $0x31323737 // .asciz 4, '7721616029739379' + WORD $0x30363136 // .asciz 4, '6160297393798828' + WORD $0x33373932 // .asciz 4, '297393798828125\x00' + WORD $0x39373339 // .asciz 4, '93798828125\x00\x00\x00\x00\x00' + WORD $0x38323838 // .asciz 4, '8828125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000e // .long 14 + WORD $0x34383635 // .asciz 4, '5684341886080801' + WORD $0x38313433 // .asciz 4, '3418860808014869' + WORD $0x38303638 // .asciz 4, '8608080148696899' + WORD $0x31303830 // .asciz 4, '0801486968994140' + WORD $0x39363834 // .asciz 4, '486968994140625\x00' + WORD $0x39393836 // .asciz 4, '68994140625\x00\x00\x00\x00\x00' + WORD $0x30343134 // .asciz 4, '4140625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000e // .long 14 + WORD $0x32343832 // .asciz 4, '2842170943040400' + WORD $0x39303731 // .asciz 4, '1709430404007434' + WORD $0x34303334 // .asciz 4, '4304040074348449' + WORD $0x30303430 // .asciz 4, '0400743484497070' + WORD $0x34333437 // .asciz 4, '7434844970703125' + WORD $0x39343438 // .asciz 4, '844970703125\x00\x00\x00\x00' + WORD $0x30373037 // .asciz 4, '70703125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323133 // .asciz 4, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000e // .long 14 + WORD $0x31323431 // .asciz 4, '1421085471520200' + WORD $0x34353830 // .asciz 4, '0854715202003717' + WORD $0x32353137 // .asciz 4, '7152020037174224' + WORD $0x30303230 // .asciz 4, '0200371742248535' + WORD $0x37313733 // .asciz 4, '3717422485351562' + WORD $0x34323234 // .asciz 4, '4224853515625\x00\x00\x00' + WORD $0x35333538 // .asciz 4, '853515625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363531 // .asciz 4, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000f // .long 15 + WORD $0x35303137 // .asciz 4, '7105427357601001' + WORD $0x33373234 // .asciz 4, '4273576010018587' + WORD $0x30363735 // .asciz 4, '5760100185871124' + WORD $0x31303031 // .asciz 4, '1001858711242675' + WORD $0x37383538 // .asciz 4, '8587112426757812' + WORD $0x34323131 // .asciz 4, '1124267578125\x00\x00\x00' + WORD $0x35373632 // .asciz 4, '267578125\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32313837 // .asciz 4, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000f // .long 15 + WORD $0x32353533 // .asciz 4, '3552713678800500' + WORD $0x36333137 // .asciz 4, '7136788005009293' + WORD $0x30383837 // .asciz 4, '7880050092935562' + WORD $0x30303530 // .asciz 4, '0500929355621337' + WORD $0x33393239 // .asciz 4, '9293556213378906' + WORD $0x32363535 // .asciz 4, '55621337890625\x00\x00' + WORD $0x37333331 // .asciz 4, '1337890625\x00\x00\x00\x00\x00\x00' + WORD $0x36303938 // .asciz 4, '890625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000f // .long 15 + WORD $0x36373731 // .asciz 4, '1776356839400250' + WORD $0x38363533 // .asciz 4, '3568394002504646' + WORD $0x30343933 // .asciz 4, '3940025046467781' + WORD $0x30353230 // .asciz 4, '0250464677810668' + WORD $0x36343634 // .asciz 4, '4646778106689453' + WORD $0x31383737 // .asciz 4, '778106689453125\x00' + WORD $0x38363630 // .asciz 4, '06689453125\x00\x00\x00\x00\x00' + WORD $0x33353439 // .asciz 4, '9453125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000010 // .long 16 + WORD $0x31383838 // .asciz 4, '8881784197001252' + WORD $0x31343837 // .asciz 4, '7841970012523233' + WORD $0x30303739 // .asciz 4, '9700125232338905' + WORD $0x32353231 // .asciz 4, '1252323389053344' + WORD $0x33333233 // .asciz 4, '3233890533447265' + WORD $0x35303938 // .asciz 4, '890533447265625\x00' + WORD $0x34343333 // .asciz 4, '33447265625\x00\x00\x00\x00\x00' + WORD $0x35363237 // .asciz 4, '7265625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000010 // .long 16 + WORD $0x30343434 // .asciz 4, '4440892098500626' + WORD $0x30323938 // .asciz 4, '8920985006261616' + WORD $0x30353839 // .asciz 4, '9850062616169452' + WORD $0x36323630 // .asciz 4, '0626161694526672' + WORD $0x36313631 // .asciz 4, '1616945266723632' + WORD $0x32353439 // .asciz 4, '9452667236328125' + WORD $0x32373636 // .asciz 4, '667236328125\x00\x00\x00\x00' + WORD $0x32333633 // .asciz 4, '36328125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323138 // .asciz 4, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000010 // .long 16 + WORD $0x30323232 // .asciz 4, '2220446049250313' + WORD $0x30363434 // .asciz 4, '4460492503130808' + WORD $0x35323934 // .asciz 4, '4925031308084726' + WORD $0x33313330 // .asciz 4, '0313080847263336' + WORD $0x38303830 // .asciz 4, '0808472633361816' + WORD $0x36323734 // .asciz 4, '4726333618164062' + WORD $0x36333333 // .asciz 4, '3336181640625\x00\x00\x00' + WORD $0x36313831 // .asciz 4, '181640625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363034 // .asciz 4, '40625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000010 // .long 16 + WORD $0x30313131 // .asciz 4, '1110223024625156' + WORD $0x30333232 // .asciz 4, '2230246251565404' + WORD $0x32363432 // .asciz 4, '2462515654042363' + WORD $0x36353135 // .asciz 4, '5156540423631668' + WORD $0x34303435 // .asciz 4, '5404236316680908' + WORD $0x33363332 // .asciz 4, '2363166809082031' + WORD $0x38363631 // .asciz 4, '16680908203125\x00\x00' + WORD $0x38303930 // .asciz 4, '0908203125\x00\x00\x00\x00\x00\x00' + WORD $0x31333032 // .asciz 4, '203125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000011 // .long 17 + WORD $0x31353535 // .asciz 4, '5551115123125782' + WORD $0x31353131 // .asciz 4, '1151231257827021' + WORD $0x32313332 // .asciz 4, '2312578270211815' + WORD $0x32383735 // .asciz 4, '5782702118158340' + WORD $0x31323037 // .asciz 4, '7021181583404541' + WORD $0x35313831 // .asciz 4, '1815834045410156' + WORD $0x30343338 // .asciz 4, '83404541015625\x00\x00' + WORD $0x31343534 // .asciz 4, '4541015625\x00\x00\x00\x00\x00\x00' + WORD $0x36353130 // .asciz 4, '015625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000011 // .long 17 + WORD $0x35373732 // .asciz 4, '2775557561562891' + WORD $0x35373535 // .asciz 4, '5575615628913510' + WORD $0x36353136 // .asciz 4, '6156289135105907' + WORD $0x31393832 // .asciz 4, '2891351059079170' + WORD $0x30313533 // .asciz 4, '3510590791702270' + WORD $0x37303935 // .asciz 4, '5907917022705078' + WORD $0x30373139 // .asciz 4, '917022705078125\x00' + WORD $0x30373232 // .asciz 4, '22705078125\x00\x00\x00\x00\x00' + WORD $0x38373035 // .asciz 4, '5078125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000011 // .long 17 + WORD $0x37383331 // .asciz 4, '1387778780781445' + WORD $0x37383737 // .asciz 4, '7787807814456755' + WORD $0x38373038 // .asciz 4, '8078144567552953' + WORD $0x35343431 // .asciz 4, '1445675529539585' + WORD $0x35353736 // .asciz 4, '6755295395851135' + WORD $0x33353932 // .asciz 4, '2953958511352539' + WORD $0x35383539 // .asciz 4, '9585113525390625' + WORD $0x35333131 // .asciz 4, '113525390625\x00\x00\x00\x00' + WORD $0x39333532 // .asciz 4, '25390625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323630 // .asciz 4, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000012 // .long 18 + WORD $0x38333936 // .asciz 4, '6938893903907228' + WORD $0x39333938 // .asciz 4, '8939039072283776' + WORD $0x30393330 // .asciz 4, '0390722837764769' + WORD $0x38323237 // .asciz 4, '7228377647697925' + WORD $0x36373733 // .asciz 4, '3776476979255676' + WORD $0x39363734 // .asciz 4, '4769792556762695' + WORD $0x35323937 // .asciz 4, '7925567626953125' + WORD $0x36373635 // .asciz 4, '567626953125\x00\x00\x00\x00' + WORD $0x35393632 // .asciz 4, '26953125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323133 // .asciz 4, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000012 // .long 18 + WORD $0x39363433 // .asciz 4, '3469446951953614' + WORD $0x39363434 // .asciz 4, '4469519536141888' + WORD $0x35393135 // .asciz 4, '5195361418882384' + WORD $0x34313633 // .asciz 4, '3614188823848962' + WORD $0x38383831 // .asciz 4, '1888238489627838' + WORD $0x34383332 // .asciz 4, '2384896278381347' + WORD $0x32363938 // .asciz 4, '8962783813476562' + WORD $0x38333837 // .asciz 4, '7838134765625\x00\x00\x00' + WORD $0x37343331 // .asciz 4, '134765625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363536 // .asciz 4, '65625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000012 // .long 18 + WORD $0x34333731 // .asciz 4, '1734723475976807' + WORD $0x34333237 // .asciz 4, '7234759768070944' + WORD $0x37393537 // .asciz 4, '7597680709441192' + WORD $0x37303836 // .asciz 4, '6807094411924481' + WORD $0x34343930 // .asciz 4, '0944119244813919' + WORD $0x32393131 // .asciz 4, '1192448139190673' + WORD $0x31383434 // .asciz 4, '4481391906738281' + WORD $0x39313933 // .asciz 4, '39190673828125\x00\x00' + WORD $0x33373630 // .asciz 4, '0673828125\x00\x00\x00\x00\x00\x00' + WORD $0x31383238 // .asciz 4, '828125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000013 // .long 19 + WORD $0x33373638 // .asciz 4, '8673617379884035' + WORD $0x33373136 // .asciz 4, '6173798840354720' + WORD $0x38383937 // .asciz 4, '7988403547205962' + WORD $0x35333034 // .asciz 4, '4035472059622406' + WORD $0x30323734 // .asciz 4, '4720596224069595' + WORD $0x32363935 // .asciz 4, '5962240695953369' + WORD $0x36303432 // .asciz 4, '2406959533691406' + WORD $0x35393539 // .asciz 4, '95953369140625\x00\x00' + WORD $0x39363333 // .asciz 4, '3369140625\x00\x00\x00\x00\x00\x00' + WORD $0x36303431 // .asciz 4, '140625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + +TEXT ·__value(SB), $0-48 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $128, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_value: + MOVD s+0(FP), R0 + MOVD n+8(FP), R1 + MOVD p+16(FP), R2 + MOVD v+24(FP), R3 + MOVD flags+32(FP), R4 + CALL ·__value_arm64_entry__+60(SB) // _value + MOVD R0, ret+40(FP) + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/value_subr_arm64.go b/internal/native/neon/value_subr_arm64.go new file mode 100644 index 000000000..5a37f30f2 --- /dev/null +++ b/internal/native/neon/value_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __value_arm64_entry__() uintptr + +var ( + _subr__value uintptr = __value_arm64_entry__() + 48 +) + +const ( + _stack__value = 96 +) + +var ( + _ = _subr__value +) + +const ( + _ = _stack__value +) diff --git a/internal/native/neon/vnumber_arm64.go b/internal/native/neon/vnumber_arm64.go new file mode 100644 index 000000000..8bb254445 --- /dev/null +++ b/internal/native/neon/vnumber_arm64.go @@ -0,0 +1,34 @@ + +/* + * 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 neon + +import ( + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func vnumber(s *string, p *int, v *types.JsonState) { + __vnumber(s, p, v) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vnumber(s *string, p *int, v *types.JsonState) + + diff --git a/internal/native/neon/vnumber_arm64.s b/internal/native/neon/vnumber_arm64.s new file mode 100644 index 000000000..965484385 --- /dev/null +++ b/internal/native/neon/vnumber_arm64.s @@ -0,0 +1,4859 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__vnumber_arm64_entry__(SB), NOSPLIT, $96 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x9101c3ff // add sp, sp, #112 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_vnumber: + MOVD.W R30, -112(RSP) // WORD $0xf8190ffe // str x30, [sp, #-112]! + WORD $0xa9026ffc // stp x28, x27, [sp, #32] + WORD $0xa90367fa // stp x26, x25, [sp, #48] + WORD $0xa9045ff8 // stp x24, x23, [sp, #64] + WORD $0xa90557f6 // stp x22, x21, [sp, #80] + WORD $0xa9064ff4 // stp x20, x19, [sp, #96] + WORD $0xa940200e // ldp x14, x8, [x0] + WORD $0xf9400031 // ldr x17, [x1] + WORD $0xa9422849 // ldp x9, x10, [x2, #32] + WORD $0x5280012b // mov w11, #9 + WORD $0xa900fc5f // stp xzr, xzr, [x2, #8] + WORD $0xf900004b // str x11, [x2] + WORD $0xf940002b // ldr x11, [x1] + WORD $0xf9000c4b // str x11, [x2, #24] + WORD $0xeb08023f // cmp x17, x8 + WORD $0x54001502 // b.hs LBB0_48 $672(%rip) + WORD $0x387169cb // ldrb w11, [x14, x17] + WORD $0x7100b57f // cmp w11, #45 + WORD $0x54000141 // b.ne LBB0_4 $40(%rip) + WORD $0x91000631 // add x17, x17, #1 + WORD $0xeb08023f // cmp x17, x8 + WORD $0x54001442 // b.hs LBB0_48 $648(%rip) + WORD $0x387169cf // ldrb w15, [x14, x17] + WORD $0x1280000d // mov w13, #-1 + WORD $0x5100e9ec // sub w12, w15, #58 + WORD $0x31002d9f // cmn w12, #11 + WORD $0x540000e9 // b.ls LBB0_5 $28(%rip) + WORD $0x14000009 // b LBB0_7 $36(%rip) +LBB0_4: + WORD $0x5280002d // mov w13, #1 + WORD $0xaa0b03ef // mov x15, x11 + WORD $0x5100e9ec // sub w12, w15, #58 + WORD $0x31002d9f // cmn w12, #11 + WORD $0x54000088 // b.hi LBB0_7 $16(%rip) +LBB0_5: + WORD $0xf9000031 // str x17, [x1] +LBB0_6: + WORD $0x92800028 // mov x8, #-2 + WORD $0x14000096 // b LBB0_49 $600(%rip) +LBB0_7: + WORD $0x7100c1ff // cmp w15, #48 + WORD $0x540001c1 // b.ne LBB0_10 $56(%rip) + WORD $0x9100062c // add x12, x17, #1 + WORD $0xeb08023f // cmp x17, x8 + WORD $0x540006e2 // b.hs LBB0_19 $220(%rip) + WORD $0x386c69d0 // ldrb w16, [x14, x12] + WORD $0x5100ba10 // sub w16, w16, #46 + WORD $0x7100de1f // cmp w16, #55 + WORD $0x52800020 // mov w0, #1 + WORD $0x9ad02010 // lsl x16, x0, x16 + WORD $0xb20903e0 // mov x0, #36028797027352576 + WORD $0xf2800020 // movk x0, #1 + WORD $0x8a000210 // and x16, x16, x0 + WORD $0xfa409a04 // ccmp x16, #0, #4, ls + WORD $0x540005a0 // b.eq LBB0_19 $180(%rip) +LBB0_10: + WORD $0xeb08023f // cmp x17, x8 + WORD $0x54000462 // b.hs LBB0_18 $140(%rip) + WORD $0x52800010 // mov w16, #0 + WORD $0x52800003 // mov w3, #0 + WORD $0xd280000c // mov x12, #0 + WORD $0x128005e0 // mov w0, #-48 + WORD $0x91000631 // add x17, x17, #1 + WORD $0x52800144 // mov w4, #10 +LBB0_12: + WORD $0x7100487f // cmp w3, #18 + WORD $0x0b2f000f // add w15, w0, w15, uxtb + WORD $0x9b043d8f // madd x15, x12, x4, x15 + WORD $0x1a90d610 // cinc w16, w16, gt + WORD $0x1a83c463 // cinc w3, w3, le + WORD $0x9a8fc18c // csel x12, x12, x15, gt + WORD $0xeb11011f // cmp x8, x17 + WORD $0x540003e0 // b.eq LBB0_20 $124(%rip) + WORD $0x387169cf // ldrb w15, [x14, x17] + WORD $0x5100c1e5 // sub w5, w15, #48 + WORD $0x91000631 // add x17, x17, #1 + WORD $0x710028bf // cmp w5, #10 + WORD $0x54fffe83 // b.lo LBB0_12 $-48(%rip) + WORD $0x7100b9ff // cmp w15, #46 + WORD $0x540003c1 // b.ne LBB0_21 $120(%rip) + WORD $0x5280010f // mov w15, #8 + WORD $0xf900004f // str x15, [x2] + WORD $0xeb08023f // cmp x17, x8 + WORD $0x54000d42 // b.hs LBB0_48 $424(%rip) + WORD $0x387169cf // ldrb w15, [x14, x17] + WORD $0x5100e9ef // sub w15, w15, #58 + WORD $0x31002dff // cmn w15, #11 + WORD $0x54fffa09 // b.ls LBB0_5 $-192(%rip) + WORD $0x52800000 // mov w0, #0 + WORD $0x7100021f // cmp w16, #0 + WORD $0x1a9fd7ef // cset w15, gt + WORD $0xb40002ec // cbz x12, LBB0_22 $92(%rip) + WORD $0x14000028 // b LBB0_30 $160(%rip) +LBB0_18: + WORD $0x52800010 // mov w16, #0 + WORD $0x52800003 // mov w3, #0 + WORD $0xd280000c // mov x12, #0 + WORD $0x52800020 // mov w0, #1 + WORD $0x7100021f // cmp w16, #0 + WORD $0x1a9fd7ef // cset w15, gt + WORD $0xb40001ec // cbz x12, LBB0_22 $60(%rip) + WORD $0x14000020 // b LBB0_30 $128(%rip) +LBB0_19: + WORD $0xf900002c // str x12, [x1] + WORD $0x1400005a // b LBB0_50 $360(%rip) +LBB0_20: + WORD $0x52800020 // mov w0, #1 + WORD $0xaa0803f1 // mov x17, x8 + WORD $0x7100021f // cmp w16, #0 + WORD $0x1a9fd7ef // cset w15, gt + WORD $0xb40000ec // cbz x12, LBB0_22 $28(%rip) + WORD $0x14000018 // b LBB0_30 $96(%rip) +LBB0_21: + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0x52800020 // mov w0, #1 + WORD $0x7100021f // cmp w16, #0 + WORD $0x1a9fd7ef // cset w15, gt + WORD $0xb500026c // cbnz x12, LBB0_30 $76(%rip) +LBB0_22: + WORD $0x35000250 // cbnz w16, LBB0_30 $72(%rip) + WORD $0xeb08023f // cmp x17, x8 + WORD $0x540001a2 // b.hs LBB0_28 $52(%rip) + WORD $0x52800010 // mov w16, #0 + WORD $0x4b080223 // sub w3, w17, w8 +LBB0_25: + WORD $0x387169cc // ldrb w12, [x14, x17] + WORD $0x7100c19f // cmp w12, #48 + WORD $0x54000121 // b.ne LBB0_29 $36(%rip) + WORD $0x91000631 // add x17, x17, #1 + WORD $0x51000610 // sub w16, w16, #1 + WORD $0xeb11011f // cmp x8, x17 + WORD $0x54ffff41 // b.ne LBB0_25 $-24(%rip) + WORD $0xd280000c // mov x12, #0 + WORD $0x35000960 // cbnz w0, LBB0_52 $300(%rip) + WORD $0x14000053 // b LBB0_56 $332(%rip) +LBB0_28: + WORD $0x52800010 // mov w16, #0 +LBB0_29: + WORD $0x52800003 // mov w3, #0 + WORD $0xd280000c // mov x12, #0 +LBB0_30: + WORD $0xeb08023f // cmp x17, x8 + WORD $0x54000262 // b.hs LBB0_36 $76(%rip) + WORD $0x7100487f // cmp w3, #18 + WORD $0x5400022c // b.gt LBB0_36 $68(%rip) + WORD $0x128005e4 // mov w4, #-48 + WORD $0x52800145 // mov w5, #10 +LBB0_33: + WORD $0x387169c6 // ldrb w6, [x14, x17] + WORD $0x5100c0c7 // sub w7, w6, #48 + WORD $0x710024ff // cmp w7, #9 + WORD $0x54000168 // b.hi LBB0_36 $44(%rip) + WORD $0x0b0400c6 // add w6, w6, w4 + WORD $0x9b05198c // madd x12, x12, x5, x6 + WORD $0x51000610 // sub w16, w16, #1 + WORD $0x91000631 // add x17, x17, #1 + WORD $0xeb08023f // cmp x17, x8 + WORD $0x540000a2 // b.hs LBB0_36 $20(%rip) + WORD $0x11000466 // add w6, w3, #1 + WORD $0x7100487f // cmp w3, #18 + WORD $0xaa0603e3 // mov x3, x6 + WORD $0x54fffe6b // b.lt LBB0_33 $-52(%rip) +LBB0_36: + WORD $0xeb08023f // cmp x17, x8 + WORD $0x540005c2 // b.hs LBB0_51 $184(%rip) + WORD $0x387169c3 // ldrb w3, [x14, x17] + WORD $0x5100c064 // sub w4, w3, #48 + WORD $0x7100249f // cmp w4, #9 + WORD $0x54000168 // b.hi LBB0_42 $44(%rip) + WORD $0x910005cf // add x15, x14, #1 + WORD $0xd1000504 // sub x4, x8, #1 +LBB0_39: + WORD $0xeb11009f // cmp x4, x17 + WORD $0x54000ae0 // b.eq LBB0_64 $348(%rip) + WORD $0x387169e3 // ldrb w3, [x15, x17] + WORD $0x5100c065 // sub w5, w3, #48 + WORD $0x91000631 // add x17, x17, #1 + WORD $0x710024bf // cmp w5, #9 + WORD $0x54ffff49 // b.ls LBB0_39 $-24(%rip) + WORD $0x5280002f // mov w15, #1 +LBB0_42: + WORD $0x321b0063 // orr w3, w3, #0x20 + WORD $0x7101947f // cmp w3, #101 + WORD $0x540003a1 // b.ne LBB0_51 $116(%rip) + WORD $0x91000620 // add x0, x17, #1 + WORD $0x52800103 // mov w3, #8 + WORD $0xf9000043 // str x3, [x2] + WORD $0xeb08001f // cmp x0, x8 + WORD $0x540001c2 // b.hs LBB0_48 $56(%rip) + WORD $0x386069c3 // ldrb w3, [x14, x0] + WORD $0x7100b47f // cmp w3, #45 + WORD $0x54000060 // b.eq LBB0_46 $12(%rip) + WORD $0x7100ac7f // cmp w3, #43 + WORD $0x54001b81 // b.ne LBB0_90 $880(%rip) +LBB0_46: + WORD $0x91000a20 // add x0, x17, #2 + WORD $0xeb08001f // cmp x0, x8 + WORD $0x540000c2 // b.hs LBB0_48 $24(%rip) + WORD $0x7100ac7f // cmp w3, #43 + WORD $0x52800031 // mov w17, #1 + WORD $0x5a910631 // cneg w17, w17, ne + WORD $0x386069c3 // ldrb w3, [x14, x0] + WORD $0x140000d5 // b LBB0_91 $852(%rip) +LBB0_48: + WORD $0xf9000028 // str x8, [x1] + WORD $0x92800008 // mov x8, #-1 +LBB0_49: + WORD $0xf9000048 // str x8, [x2] +LBB0_50: + WORD $0xa9464ff4 // ldp x20, x19, [sp, #96] + WORD $0xa94557f6 // ldp x22, x21, [sp, #80] + WORD $0xa9445ff8 // ldp x24, x23, [sp, #64] + WORD $0xa94367fa // ldp x26, x25, [sp, #48] + WORD $0xa9426ffc // ldp x28, x27, [sp, #32] + WORD $0x9101c3ff // add sp, sp, #112 + WORD $0xd65f03c0 // ret +LBB0_51: + WORD $0xaa1003e3 // mov x3, x16 + WORD $0xaa1103e8 // mov x8, x17 + WORD $0x34000140 // cbz w0, LBB0_56 $40(%rip) +LBB0_52: + WORD $0x350000e3 // cbnz w3, LBB0_55 $28(%rip) + WORD $0x93407db0 // sxtw x16, w13 + WORD $0xb6f80f0c // tbz x12, #63, LBB0_76 $480(%rip) + WORD $0x8a100191 // and x17, x12, x16 + WORD $0xd2f00000 // mov x0, #-9223372036854775808 + WORD $0xeb00023f // cmp x17, x0 + WORD $0x54000e80 // b.eq LBB0_76 $464(%rip) +LBB0_55: + WORD $0x52800110 // mov w16, #8 + WORD $0xf9000050 // str x16, [x2] +LBB0_56: + WORD $0xd374fd90 // lsr x16, x12, #52 + WORD $0xb5000610 // cbnz x16, LBB0_67 $192(%rip) + WORD $0x9e630180 // ucvtf d0, x12 + WORD $0x9e660010 // fmov x16, d0 + WORD $0x531f7dad // lsr w13, w13, #31 + WORD $0xaa0dfe0d // orr x13, x16, x13, lsl #63 + WORD $0x9e6701a0 // fmov d0, x13 + WORD $0xb4002cec // cbz x12, LBB0_143 $1436(%rip) + WORD $0x34002cc3 // cbz w3, LBB0_143 $1432(%rip) + WORD $0x5100046d // sub w13, w3, #1 + WORD $0x710091bf // cmp w13, #36 + WORD $0x540003c8 // b.hi LBB0_65 $120(%rip) + WORD $0xaa0303ed // mov x13, x3 + WORD $0x71005c7f // cmp w3, #23 + WORD $0x540000e3 // b.lo LBB0_62 $28(%rip) + WORD $0x5100586d // sub w13, w3, #22 +Lloh0: + WORD $0x1000a590 // adr x16, _P10_TAB $5296(%rip) +Lloh1: + WORD $0x91000210 // add x16, x16, _P10_TAB@PAGEOFF $0(%rip) + WORD $0xfc6d5a01 // ldr d1, [x16, w13, uxtw #3] + WORD $0x1e600820 // fmul d0, d1, d0 + WORD $0x528002cd // mov w13, #22 +LBB0_62: + WORD $0xd2a4c690 // mov x16, #640942080 + WORD $0xf2cd7eb0 // movk x16, #27637, lsl #32 + WORD $0xf2e86190 // movk x16, #17164, lsl #48 + WORD $0x9e670201 // fmov d1, x16 + WORD $0x1e612000 // fcmp d0, d1 + WORD $0xd2a4c690 // mov x16, #640942080 + WORD $0xf2cd7eb0 // movk x16, #27637, lsl #32 + WORD $0xf2f86190 // movk x16, #49932, lsl #48 + WORD $0x9e670201 // fmov d1, x16 + WORD $0x1e61d408 // fccmp d0, d1, #8, le + WORD $0x540002a4 // b.mi LBB0_68 $84(%rip) +Lloh2: + WORD $0x1000a389 // adr x9, _P10_TAB $5232(%rip) +Lloh3: + WORD $0x91000129 // add x9, x9, _P10_TAB@PAGEOFF $0(%rip) + WORD $0xfc6d5921 // ldr d1, [x9, w13, uxtw #3] + WORD $0x1e610800 // fmul d0, d0, d1 + WORD $0x1400014a // b LBB0_143 $1320(%rip) +LBB0_64: + WORD $0x5280002f // mov w15, #1 + WORD $0xaa1003e3 // mov x3, x16 + WORD $0x35fffa00 // cbnz w0, LBB0_52 $-192(%rip) + WORD $0x17ffffd8 // b LBB0_56 $-160(%rip) +LBB0_65: + WORD $0x3100587f // cmn w3, #22 + WORD $0x540000e3 // b.lo LBB0_67 $28(%rip) + WORD $0x4b0303e9 // neg w9, w3 +Lloh4: + WORD $0x1000a20a // adr x10, _P10_TAB $5184(%rip) +Lloh5: + WORD $0x9100014a // add x10, x10, _P10_TAB@PAGEOFF $0(%rip) + WORD $0xfc695941 // ldr d1, [x10, w9, uxtw #3] + WORD $0x1e611800 // fdiv d0, d0, d1 + WORD $0x1400013e // b LBB0_143 $1272(%rip) +LBB0_67: + WORD $0x5105706d // sub w13, w3, #348 + WORD $0x310ae1bf // cmn w13, #696 + WORD $0x54000663 // b.lo LBB0_72 $204(%rip) +LBB0_68: + WORD $0xdac01184 // clz x4, x12 + WORD $0x9ac42187 // lsl x7, x12, x4 + WORD $0x11057070 // add w16, w3, #348 +Lloh6: + WORD $0x1000a671 // adr x17, _POW10_M128_TAB $5324(%rip) +Lloh7: + WORD $0x91000231 // add x17, x17, _POW10_M128_TAB@PAGEOFF $0(%rip) + WORD $0x8b30522d // add x13, x17, w16, uxtw #4 + WORD $0xf94005a0 // ldr x0, [x13, #8] + WORD $0x9b077c0d // mul x13, x0, x7 + WORD $0x9bc77c05 // umulh x5, x0, x7 + WORD $0x924020a6 // and x6, x5, #0x1ff + WORD $0xaa2703f3 // mvn x19, x7 + WORD $0xf107fcdf // cmp x6, #511 + WORD $0xfa5301a0 // ccmp x13, x19, #0, eq + WORD $0x54000189 // b.ls LBB0_70 $48(%rip) + WORD $0xd37cee06 // lsl x6, x16, #4 + WORD $0xf8666a26 // ldr x6, [x17, x6] + WORD $0x9b077cd4 // mul x20, x6, x7 + WORD $0x9bc77cc6 // umulh x6, x6, x7 + WORD $0xab0d00cd // adds x13, x6, x13 + WORD $0x9a8534a5 // cinc x5, x5, hs + WORD $0x924020a6 // and x6, x5, #0x1ff + WORD $0xf107fcdf // cmp x6, #511 + WORD $0xba4109a0 // ccmn x13, #1, #0, eq + WORD $0xfa530280 // ccmp x20, x19, #0, eq + WORD $0x54000348 // b.hi LBB0_72 $104(%rip) +LBB0_70: + WORD $0xd37ffca7 // lsr x7, x5, #63 + WORD $0x910024f3 // add x19, x7, #9 + WORD $0x9ad324a5 // lsr x5, x5, x19 + WORD $0x924004b3 // and x19, x5, #0x3 + WORD $0xf10001bf // cmp x13, #0 + WORD $0xfa4008c0 // ccmp x6, #0, #0, eq + WORD $0xfa410a60 // ccmp x19, #1, #0, eq + WORD $0x54000240 // b.eq LBB0_72 $72(%rip) + WORD $0x528a4d4d // mov w13, #21098 + WORD $0x72a0006d // movk w13, #3, lsl #16 + WORD $0x1b0d7c6d // mul w13, w3, w13 + WORD $0x13107dad // asr w13, w13, #16 + WORD $0x1110fdad // add w13, w13, #1087 + WORD $0x93407dad // sxtw x13, w13 + WORD $0x924000a3 // and x3, x5, #0x1 + WORD $0x8b050063 // add x3, x3, x5 + WORD $0xd376fc65 // lsr x5, x3, #54 + WORD $0xf10000bf // cmp x5, #0 + WORD $0x1a9f17e6 // cset w6, eq + WORD $0xcb0401a4 // sub x4, x13, x4 + WORD $0x8b070084 // add x4, x4, x7 + WORD $0xcb060084 // sub x4, x4, x6 + WORD $0xd11ffc86 // sub x6, x4, #2047 + WORD $0xb11ff8df // cmn x6, #2046 + WORD $0x540002e2 // b.hs LBB0_79 $92(%rip) +LBB0_72: + WORD $0xf940002f // ldr x15, [x1] + WORD $0x8b0f01c0 // add x0, x14, x15 + WORD $0xcb0f0111 // sub x17, x8, x15 + WORD $0xb400122a // cbz x10, LBB0_110 $580(%rip) + WORD $0x3900013f // strb wzr, [x9] + WORD $0xf100054b // subs x11, x10, #1 + WORD $0x540011c0 // b.eq LBB0_110 $568(%rip) + WORD $0xf100217f // cmp x11, #8 + WORD $0x54000142 // b.hs LBB0_77 $40(%rip) + WORD $0x5280002c // mov w12, #1 + WORD $0x14000085 // b LBB0_108 $532(%rip) +LBB0_76: + WORD $0x9b107d89 // mul x9, x12, x16 + WORD $0x9e630180 // ucvtf d0, x12 + WORD $0x9241020a // and x10, x16, #0x8000000000000000 + WORD $0x9e66000b // fmov x11, d0 + WORD $0xaa0b014a // orr x10, x10, x11 + WORD $0xa900a44a // stp x10, x9, [x2, #8] + WORD $0x140000ff // b LBB0_146 $1020(%rip) +LBB0_77: + WORD $0xf100817f // cmp x11, #32 + WORD $0x54000ba2 // b.hs LBB0_97 $372(%rip) + WORD $0xd280000d // mov x13, #0 + WORD $0x14000067 // b LBB0_101 $412(%rip) +LBB0_79: + WORD $0xf10000bf // cmp x5, #0 + WORD $0x52800025 // mov w5, #1 + WORD $0x9a8504a5 // cinc x5, x5, ne + WORD $0x9ac52463 // lsr x3, x3, x5 + WORD $0xb34c2c83 // bfi x3, x4, #52, #12 + WORD $0xb2410064 // orr x4, x3, #0x8000000000000000 + WORD $0x7100b57f // cmp w11, #45 + WORD $0x9a830083 // csel x3, x4, x3, eq + WORD $0x9e670060 // fmov d0, x3 + WORD $0x34001d2f // cbz w15, LBB0_143 $932(%rip) + WORD $0x9100058f // add x15, x12, #1 + WORD $0xdac011ec // clz x12, x15 + WORD $0x9acc21e4 // lsl x4, x15, x12 + WORD $0x9b047c0f // mul x15, x0, x4 + WORD $0x9bc47c00 // umulh x0, x0, x4 + WORD $0x92402003 // and x3, x0, #0x1ff + WORD $0xf107fc7f // cmp x3, #511 + WORD $0x54000221 // b.ne LBB0_85 $68(%rip) + WORD $0xaa2403e5 // mvn x5, x4 + WORD $0xeb0501ff // cmp x15, x5 + WORD $0x540001c9 // b.ls LBB0_85 $56(%rip) + WORD $0xd37cee10 // lsl x16, x16, #4 + WORD $0xf8706a30 // ldr x16, [x17, x16] + WORD $0x9bc47e11 // umulh x17, x16, x4 + WORD $0xab0f022f // adds x15, x17, x15 + WORD $0x9a803400 // cinc x0, x0, hs + WORD $0x92402003 // and x3, x0, #0x1ff + WORD $0xf107fc7f // cmp x3, #511 + WORD $0x540000c1 // b.ne LBB0_85 $24(%rip) + WORD $0xb10005ff // cmn x15, #1 + WORD $0x54000081 // b.ne LBB0_85 $16(%rip) + WORD $0x9b047e10 // mul x16, x16, x4 + WORD $0xeb05021f // cmp x16, x5 + WORD $0x54fff928 // b.hi LBB0_72 $-220(%rip) +LBB0_85: + WORD $0xd37ffc10 // lsr x16, x0, #63 + WORD $0x91002611 // add x17, x16, #9 + WORD $0x9ad12411 // lsr x17, x0, x17 + WORD $0xb50000af // cbnz x15, LBB0_88 $20(%rip) + WORD $0xb5000083 // cbnz x3, LBB0_88 $16(%rip) + WORD $0x9240062f // and x15, x17, #0x3 + WORD $0xf10005ff // cmp x15, #1 + WORD $0x54fff820 // b.eq LBB0_72 $-252(%rip) +LBB0_88: + WORD $0x9240022f // and x15, x17, #0x1 + WORD $0x8b1101ef // add x15, x15, x17 + WORD $0xd376fdf1 // lsr x17, x15, #54 + WORD $0xf100023f // cmp x17, #0 + WORD $0x1a9f17e0 // cset w0, eq + WORD $0xcb0c01ac // sub x12, x13, x12 + WORD $0x8b10018c // add x12, x12, x16 + WORD $0xcb00018c // sub x12, x12, x0 + WORD $0xd11ffd8d // sub x13, x12, #2047 + WORD $0xb11ff9bf // cmn x13, #2046 + WORD $0x54fff6c3 // b.lo LBB0_72 $-296(%rip) + WORD $0xf100023f // cmp x17, #0 + WORD $0x5280002d // mov w13, #1 + WORD $0x9a8d05ad // cinc x13, x13, ne + WORD $0x9acd25ed // lsr x13, x15, x13 + WORD $0xb34c2d8d // bfi x13, x12, #52, #12 + WORD $0xb24101ac // orr x12, x13, #0x8000000000000000 + WORD $0x7100b57f // cmp w11, #45 + WORD $0x9a8d018b // csel x11, x12, x13, eq + WORD $0x9e670161 // fmov d1, x11 + WORD $0x1e612000 // fcmp d0, d1 + WORD $0x54001660 // b.eq LBB0_143 $716(%rip) + WORD $0x17ffffaa // b LBB0_72 $-344(%rip) +LBB0_90: + WORD $0x52800031 // mov w17, #1 +LBB0_91: + WORD $0x5100e864 // sub w4, w3, #58 + WORD $0x3100289f // cmn w4, #10 + WORD $0x54000062 // b.hs LBB0_93 $12(%rip) + WORD $0xf9000020 // str x0, [x1] + WORD $0x17fffe93 // b LBB0_6 $-1460(%rip) +LBB0_93: + WORD $0xeb08001f // cmp x0, x8 + WORD $0x54000542 // b.hs LBB0_104 $168(%rip) + WORD $0x52800004 // mov w4, #0 + WORD $0x910005c5 // add x5, x14, #1 + WORD $0xd1000506 // sub x6, x8, #1 + WORD $0x52800147 // mov w7, #10 + WORD $0x5284e213 // mov w19, #10000 +LBB0_95: + WORD $0x1b070c83 // madd w3, w4, w7, w3 + WORD $0x5100c063 // sub w3, w3, #48 + WORD $0x6b13009f // cmp w4, w19 + WORD $0x1a84b064 // csel w4, w3, w4, lt + WORD $0xeb0000df // cmp x6, x0 + WORD $0x54000420 // b.eq LBB0_105 $132(%rip) + WORD $0x386068a3 // ldrb w3, [x5, x0] + WORD $0x5100c074 // sub w20, w3, #48 + WORD $0x91000400 // add x0, x0, #1 + WORD $0x71002a9f // cmp w20, #10 + WORD $0x54fffec3 // b.lo LBB0_95 $-40(%rip) + WORD $0x1400001c // b LBB0_106 $112(%rip) +LBB0_97: + WORD $0x927be96d // and x13, x11, #0xffffffffffffffe0 + WORD $0x9100452c // add x12, x9, #17 + WORD $0x6f00e400 // movi.2d v0, #0000000000000000 + WORD $0xaa0d03f0 // mov x16, x13 +LBB0_98: + WORD $0xad3f8180 // stp q0, q0, [x12, #-16] + WORD $0x9100818c // add x12, x12, #32 + WORD $0xf1008210 // subs x16, x16, #32 + WORD $0x54ffffa1 // b.ne LBB0_98 $-12(%rip) + WORD $0xeb0d017f // cmp x11, x13 + WORD $0x54000360 // b.eq LBB0_110 $108(%rip) + WORD $0xf27d057f // tst x11, #0x18 + WORD $0x54000260 // b.eq LBB0_107 $76(%rip) +LBB0_101: + WORD $0x927df170 // and x16, x11, #0xfffffffffffffff8 + WORD $0xb240020c // orr x12, x16, #0x1 + WORD $0x8b0901a3 // add x3, x13, x9 + WORD $0x91000463 // add x3, x3, #1 + WORD $0xcb1001ad // sub x13, x13, x16 + WORD $0x6f00e400 // movi.2d v0, #0000000000000000 +LBB0_102: + WORD $0xfc008460 // str d0, [x3], #8 + WORD $0xb10021ad // adds x13, x13, #8 + WORD $0x54ffffc1 // b.ne LBB0_102 $-8(%rip) + WORD $0xeb10017f // cmp x11, x16 + WORD $0x54000121 // b.ne LBB0_108 $36(%rip) + WORD $0x1400000d // b LBB0_110 $52(%rip) +LBB0_104: + WORD $0x52800004 // mov w4, #0 + WORD $0x14000002 // b LBB0_106 $8(%rip) +LBB0_105: + WORD $0xaa0803e0 // mov x0, x8 +LBB0_106: + WORD $0x1b114083 // madd w3, w4, w17, w16 + WORD $0xaa0003e8 // mov x8, x0 + WORD $0x17ffff0d // b LBB0_56 $-972(%rip) +LBB0_107: + WORD $0xb24001ac // orr x12, x13, #0x1 +LBB0_108: + WORD $0xcb0c014b // sub x11, x10, x12 + WORD $0x8b0c012c // add x12, x9, x12 +LBB0_109: + WORD $0x3800159f // strb wzr, [x12], #1 + WORD $0xf100056b // subs x11, x11, #1 + WORD $0x54ffffc1 // b.ne LBB0_109 $-8(%rip) +LBB0_110: + WORD $0x3940000b // ldrb w11, [x0] + WORD $0x7100b57f // cmp w11, #45 + WORD $0x1a9f17e3 // cset w3, eq + WORD $0xeb03023f // cmp x17, x3 + WORD $0x54000d0d // b.le LBB0_141 $416(%rip) + WORD $0x5280000d // mov w13, #0 + WORD $0x52800010 // mov w16, #0 + WORD $0x5280000c // mov w12, #0 + WORD $0x52800005 // mov w5, #0 + WORD $0x52800006 // mov w6, #0 + WORD $0x52800007 // mov w7, #0 + WORD $0x52800013 // mov w19, #0 + WORD $0x52800004 // mov w4, #0 + WORD $0x52800034 // mov w20, #1 + WORD $0x1400000c // b LBB0_114 $48(%rip) +LBB0_112: + WORD $0x38336935 // strb w21, [x9, x19] + WORD $0x11000610 // add w16, w16, #1 + WORD $0xaa1003e5 // mov x5, x16 + WORD $0xaa1003e6 // mov x6, x16 + WORD $0xaa1003e7 // mov x7, x16 + WORD $0xaa1003f3 // mov x19, x16 +LBB0_113: + WORD $0x91000463 // add x3, x3, #1 + WORD $0xeb11007f // cmp x3, x17 + WORD $0x1a9fa7f4 // cset w20, lt + WORD $0xeb03023f // cmp x17, x3 + WORD $0x540003c0 // b.eq LBB0_124 $120(%rip) +LBB0_114: + WORD $0x38636815 // ldrb w21, [x0, x3] + WORD $0x5100c2b6 // sub w22, w21, #48 + WORD $0x710026df // cmp w22, #9 + WORD $0x54000168 // b.hi LBB0_119 $44(%rip) + WORD $0x7100c2bf // cmp w21, #48 + WORD $0x540001c1 // b.ne LBB0_121 $56(%rip) + WORD $0x34000266 // cbz w6, LBB0_123 $76(%rip) + WORD $0x93407cb3 // sxtw x19, w5 + WORD $0xeb13015f // cmp x10, x19 + WORD $0x54fffd88 // b.hi LBB0_112 $-80(%rip) + WORD $0xaa0503e6 // mov x6, x5 + WORD $0xaa0503e7 // mov x7, x5 + WORD $0xaa0503f3 // mov x19, x5 + WORD $0x17ffffee // b LBB0_113 $-72(%rip) +LBB0_119: + WORD $0x7100babf // cmp w21, #46 + WORD $0x540001e1 // b.ne LBB0_125 $60(%rip) + WORD $0x52800024 // mov w4, #1 + WORD $0xaa1303ed // mov x13, x19 + WORD $0x17ffffe9 // b LBB0_113 $-92(%rip) +LBB0_121: + WORD $0x93407cf3 // sxtw x19, w7 + WORD $0xeb13015f // cmp x10, x19 + WORD $0x54fffc08 // b.hi LBB0_112 $-128(%rip) + WORD $0x5280002c // mov w12, #1 + WORD $0xaa0703f3 // mov x19, x7 + WORD $0x17ffffe3 // b LBB0_113 $-116(%rip) +LBB0_123: + WORD $0x52800007 // mov w7, #0 + WORD $0x52800013 // mov w19, #0 + WORD $0x510005ad // sub w13, w13, #1 + WORD $0x17ffffdf // b LBB0_113 $-132(%rip) +LBB0_124: + WORD $0xaa1103e3 // mov x3, x17 +LBB0_125: + WORD $0x7100009f // cmp w4, #0 + WORD $0x1a8d00ad // csel w13, w5, w13, eq + WORD $0x36000554 // tbz w20, #0, LBB0_137 $168(%rip) + WORD $0x38634804 // ldrb w4, [x0, w3, uxtw] + WORD $0x321b0084 // orr w4, w4, #0x20 + WORD $0x7101949f // cmp w4, #101 + WORD $0x540004c1 // b.ne LBB0_137 $152(%rip) + WORD $0x2a0303e4 // mov w4, w3 + WORD $0x91000484 // add x4, x4, #1 + WORD $0x38646800 // ldrb w0, [x0, x4] + WORD $0x7100b41f // cmp w0, #45 + WORD $0x54000100 // b.eq LBB0_129 $32(%rip) + WORD $0x52800025 // mov w5, #1 + WORD $0x11000863 // add w3, w3, #2 + WORD $0x52800026 // mov w6, #1 + WORD $0x7100ac1f // cmp w0, #43 + WORD $0x1a831083 // csel w3, w4, w3, ne + WORD $0x1a8610a0 // csel w0, w5, w6, ne + WORD $0x14000003 // b LBB0_130 $12(%rip) +LBB0_129: + WORD $0x11000863 // add w3, w3, #2 + WORD $0x12800000 // mov w0, #-1 +LBB0_130: + WORD $0x93407c63 // sxtw x3, w3 + WORD $0xeb03023f // cmp x17, x3 + WORD $0x5400026d // b.le LBB0_135 $76(%rip) + WORD $0x52800011 // mov w17, #0 + WORD $0x8b0301e3 // add x3, x15, x3 + WORD $0xcb08006f // sub x15, x3, x8 + WORD $0x8b0301ce // add x14, x14, x3 + WORD $0x5284e1e3 // mov w3, #9999 + WORD $0x52800144 // mov w4, #10 +LBB0_132: + WORD $0x39c001c5 // ldrsb w5, [x14] + WORD $0x7100c0bf // cmp w5, #48 + WORD $0x5400016b // b.lt LBB0_136 $44(%rip) + WORD $0x7100e4bf // cmp w5, #57 + WORD $0x7a439220 // ccmp w17, w3, #0, ls + WORD $0x5400010c // b.gt LBB0_136 $32(%rip) + WORD $0x1b041631 // madd w17, w17, w4, w5 + WORD $0x5100c231 // sub w17, w17, #48 + WORD $0x910005ce // add x14, x14, #1 + WORD $0xb10005ef // adds x15, x15, #1 + WORD $0x54fffec3 // b.lo LBB0_132 $-40(%rip) + WORD $0x14000002 // b LBB0_136 $8(%rip) +LBB0_135: + WORD $0x52800011 // mov w17, #0 +LBB0_136: + WORD $0x1b00362d // madd w13, w17, w0, w13 +LBB0_137: + WORD $0x34000110 // cbz w16, LBB0_141 $32(%rip) + WORD $0x7104d9bf // cmp w13, #310 + WORD $0x5400008d // b.le LBB0_140 $16(%rip) +LBB0_139: + WORD $0xd2800009 // mov x9, #0 + WORD $0xd2effe0a // mov x10, #9218868437227405312 + WORD $0x14000005 // b LBB0_142 $20(%rip) +LBB0_140: + WORD $0x310529bf // cmn w13, #330 + WORD $0x5400026a // b.ge LBB0_147 $76(%rip) +LBB0_141: + WORD $0xd280000a // mov x10, #0 + WORD $0xd2800009 // mov x9, #0 +LBB0_142: + WORD $0x9240cd29 // and x9, x9, #0xfffffffffffff + WORD $0xaa0a0129 // orr x9, x9, x10 + WORD $0xb241012a // orr x10, x9, #0x8000000000000000 + WORD $0x7100b57f // cmp w11, #45 + WORD $0x9a890149 // csel x9, x10, x9, eq + WORD $0x9e670120 // fmov d0, x9 +LBB0_143: + WORD $0x9e660009 // fmov x9, d0 + WORD $0x9240f929 // and x9, x9, #0x7fffffffffffffff + WORD $0xd2effe0a // mov x10, #9218868437227405312 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x54000061 // b.ne LBB0_145 $12(%rip) + WORD $0x928000e9 // mov x9, #-8 + WORD $0xf9000049 // str x9, [x2] +LBB0_145: + WORD $0xfd000440 // str d0, [x2, #8] +LBB0_146: + WORD $0xf9000028 // str x8, [x1] + WORD $0x17fffe76 // b LBB0_50 $-1576(%rip) +LBB0_147: +Lloh8: + WORD $0x1001dacf // adr x15, _POW_TAB $15192(%rip) +Lloh9: + WORD $0x910001ef // add x15, x15, _POW_TAB@PAGEOFF $0(%rip) + WORD $0x710005bf // cmp w13, #1 + WORD $0x54001a2b // b.lt LBB0_206 $836(%rip) + WORD $0x5280000e // mov w14, #0 + WORD $0x92800011 // mov x17, #-1 + WORD $0x52800140 // mov w0, #10 + WORD $0xaa1003f4 // mov x20, x16 + WORD $0xaa1003e4 // mov x4, x16 + WORD $0x14000007 // b LBB0_152 $28(%rip) +LBB0_149: + WORD $0x340075b4 // cbz w20, LBB0_412 $3764(%rip) +LBB0_150: + WORD $0xaa1403f0 // mov x16, x20 + WORD $0xaa1403e4 // mov x4, x20 +LBB0_151: + WORD $0x0b0e006e // add w14, w3, w14 + WORD $0x710001bf // cmp w13, #0 + WORD $0x540018ed // b.le LBB0_208 $796(%rip) +LBB0_152: + WORD $0x710021bf // cmp w13, #8 + WORD $0x540000a9 // b.ls LBB0_155 $20(%rip) + WORD $0x52800363 // mov w3, #27 + WORD $0x34ffff44 // cbz w4, LBB0_151 $-24(%rip) + WORD $0x12800347 // mov w7, #-27 + WORD $0x1400005d // b LBB0_181 $372(%rip) +LBB0_155: + WORD $0xb86d59e3 // ldr w3, [x15, w13, uxtw #2] + WORD $0x34fffec4 // cbz w4, LBB0_151 $-40(%rip) + WORD $0x4b0303e7 // neg w7, w3 + WORD $0x3100f4ff // cmn w7, #61 + WORD $0x54000109 // b.ls LBB0_160 $32(%rip) + WORD $0x14000057 // b LBB0_181 $348(%rip) +LBB0_157: + WORD $0x5280000d // mov w13, #0 +LBB0_158: + WORD $0x52800010 // mov w16, #0 +LBB0_159: + WORD $0x1100f0a7 // add w7, w5, #60 + WORD $0xaa1003e4 // mov x4, x16 + WORD $0x3101e0bf // cmn w5, #120 + WORD $0x54000a0a // b.ge LBB0_180 $320(%rip) +LBB0_160: + WORD $0xd2800013 // mov x19, #0 + WORD $0xd2800006 // mov x6, #0 + WORD $0xaa0703e5 // mov x5, x7 + WORD $0x7100009f // cmp w4, #0 + WORD $0x1a9fc087 // csel w7, w4, wzr, gt +LBB0_161: + WORD $0xeb1300ff // cmp x7, x19 + WORD $0x54000120 // b.eq LBB0_164 $36(%rip) + WORD $0x38b36934 // ldrsb x20, [x9, x19] + WORD $0x9b0050c6 // madd x6, x6, x0, x20 + WORD $0xd100c0c6 // sub x6, x6, #48 + WORD $0x91000673 // add x19, x19, #1 + WORD $0xd37cfcd4 // lsr x20, x6, #60 + WORD $0xb4ffff34 // cbz x20, LBB0_161 $-28(%rip) + WORD $0xaa1303e7 // mov x7, x19 + WORD $0x14000007 // b LBB0_166 $28(%rip) +LBB0_164: + WORD $0xb4fffd86 // cbz x6, LBB0_158 $-80(%rip) +LBB0_165: + WORD $0x8b0608d3 // add x19, x6, x6, lsl #2 + WORD $0xd37ffa66 // lsl x6, x19, #1 + WORD $0x110004e7 // add w7, w7, #1 + WORD $0xd37bfa73 // ubfx x19, x19, #59, #4 + WORD $0xb4ffff93 // cbz x19, LBB0_165 $-16(%rip) +LBB0_166: + WORD $0x4b0701ad // sub w13, w13, w7 + WORD $0x6b0400ff // cmp w7, w4 + WORD $0x5400026a // b.ge LBB0_170 $76(%rip) + WORD $0xd2800004 // mov x4, #0 + WORD $0x93407ce7 // sxtw x7, w7 + WORD $0x93407e10 // sxtw x16, w16 + WORD $0x8b070133 // add x19, x9, x7 +LBB0_168: + WORD $0xd37cfcd4 // lsr x20, x6, #60 + WORD $0x321c0694 // orr w20, w20, #0x30 + WORD $0x38246934 // strb w20, [x9, x4] + WORD $0x38a46a74 // ldrsb x20, [x19, x4] + WORD $0x9240ecc6 // and x6, x6, #0xfffffffffffffff + WORD $0x91000484 // add x4, x4, #1 + WORD $0x9b0050c6 // madd x6, x6, x0, x20 + WORD $0xd100c0c6 // sub x6, x6, #48 + WORD $0x8b0400f4 // add x20, x7, x4 + WORD $0xeb10029f // cmp x20, x16 + WORD $0x54fffecb // b.lt LBB0_168 $-40(%rip) + WORD $0xaa0403f0 // mov x16, x4 + WORD $0xb5000146 // cbnz x6, LBB0_172 $40(%rip) + WORD $0x14000014 // b LBB0_174 $80(%rip) +LBB0_170: + WORD $0x52800010 // mov w16, #0 + WORD $0x14000007 // b LBB0_172 $28(%rip) +LBB0_171: + WORD $0xf10000ff // cmp x7, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x9240ecc4 // and x4, x6, #0xfffffffffffffff + WORD $0x8b040886 // add x6, x4, x4, lsl #2 + WORD $0xd37ff8c6 // lsl x6, x6, #1 + WORD $0xb4000184 // cbz x4, LBB0_174 $48(%rip) +LBB0_172: + WORD $0x93407e04 // sxtw x4, w16 + WORD $0xd37cfcc7 // lsr x7, x6, #60 + WORD $0xeb04015f // cmp x10, x4 + WORD $0x54fffee9 // b.ls LBB0_171 $-36(%rip) + WORD $0x321c04e7 // orr w7, w7, #0x30 + WORD $0x38246927 // strb w7, [x9, x4] + WORD $0x11000610 // add w16, w16, #1 + WORD $0x9240ecc4 // and x4, x6, #0xfffffffffffffff + WORD $0x8b040886 // add x6, x4, x4, lsl #2 + WORD $0xd37ff8c6 // lsl x6, x6, #1 + WORD $0xb5fffec4 // cbnz x4, LBB0_172 $-40(%rip) +LBB0_174: + WORD $0x110005ad // add w13, w13, #1 + WORD $0x7100061f // cmp w16, #1 + WORD $0x540001cb // b.lt LBB0_179 $56(%rip) + WORD $0x2a1003e4 // mov w4, w16 + WORD $0x8b090086 // add x6, x4, x9 + WORD $0x385ff0c6 // ldurb w6, [x6, #-1] + WORD $0x7100c0df // cmp w6, #48 + WORD $0x54fff701 // b.ne LBB0_159 $-288(%rip) +LBB0_176: + WORD $0xf1000490 // subs x16, x4, #1 + WORD $0x54fff689 // b.ls LBB0_157 $-304(%rip) + WORD $0x51000884 // sub w4, w4, #2 + WORD $0x38644926 // ldrb w6, [x9, w4, uxtw] + WORD $0xaa1003e4 // mov x4, x16 + WORD $0x7100c0df // cmp w6, #48 + WORD $0x54ffff40 // b.eq LBB0_176 $-24(%rip) + WORD $0x17ffffb0 // b LBB0_159 $-320(%rip) +LBB0_179: + WORD $0x35fff5f0 // cbnz w16, LBB0_159 $-324(%rip) + WORD $0x17ffffac // b LBB0_157 $-336(%rip) +LBB0_180: + WORD $0xaa1003e4 // mov x4, x16 +LBB0_181: + WORD $0xd2800014 // mov x20, #0 + WORD $0xd2800005 // mov x5, #0 + WORD $0x4b0703e6 // neg w6, w7 + WORD $0x7100009f // cmp w4, #0 + WORD $0x1a9fc093 // csel w19, w4, wzr, gt +LBB0_182: + WORD $0xeb14027f // cmp x19, x20 + WORD $0x540003c0 // b.eq LBB0_189 $120(%rip) + WORD $0x38b46927 // ldrsb x7, [x9, x20] + WORD $0x9b001ca5 // madd x5, x5, x0, x7 + WORD $0xd100c0a5 // sub x5, x5, #48 + WORD $0x91000694 // add x20, x20, #1 + WORD $0x9ac624a7 // lsr x7, x5, x6 + WORD $0xb4ffff27 // cbz x7, LBB0_182 $-28(%rip) + WORD $0xaa1403f3 // mov x19, x20 +LBB0_185: + WORD $0x9ac62227 // lsl x7, x17, x6 + WORD $0xaa2703e7 // mvn x7, x7 + WORD $0x6b04027f // cmp w19, w4 + WORD $0x5400044a // b.ge LBB0_193 $136(%rip) + WORD $0xd2800015 // mov x21, #0 + WORD $0xaa1303e4 // mov x4, x19 + WORD $0x93407c84 // sxtw x4, w4 + WORD $0x93407e10 // sxtw x16, w16 + WORD $0x8b040134 // add x20, x9, x4 +LBB0_187: + WORD $0x9ac624b6 // lsr x22, x5, x6 + WORD $0x1100c2d6 // add w22, w22, #48 + WORD $0x38356936 // strb w22, [x9, x21] + WORD $0x38b56a96 // ldrsb x22, [x20, x21] + WORD $0x8a0700a5 // and x5, x5, x7 + WORD $0x910006b5 // add x21, x21, #1 + WORD $0x9b0058a5 // madd x5, x5, x0, x22 + WORD $0xd100c0a5 // sub x5, x5, #48 + WORD $0x8b150096 // add x22, x4, x21 + WORD $0xeb1002df // cmp x22, x16 + WORD $0x54fffecb // b.lt LBB0_187 $-40(%rip) + WORD $0xaa1503f4 // mov x20, x21 + WORD $0x14000011 // b LBB0_194 $68(%rip) +LBB0_189: + WORD $0xb40006c5 // cbz x5, LBB0_203 $216(%rip) + WORD $0x9ac624a7 // lsr x7, x5, x6 + WORD $0xb40000e7 // cbz x7, LBB0_192 $28(%rip) + WORD $0x52800014 // mov w20, #0 + WORD $0x9ac62230 // lsl x16, x17, x6 + WORD $0xaa3003e7 // mvn x7, x16 + WORD $0x4b1301ad // sub w13, w13, w19 + WORD $0x110005ad // add w13, w13, #1 + WORD $0x14000012 // b LBB0_196 $72(%rip) +LBB0_192: + WORD $0x8b0508a5 // add x5, x5, x5, lsl #2 + WORD $0xd37ff8a5 // lsl x5, x5, #1 + WORD $0x11000673 // add w19, w19, #1 + WORD $0x9ac624a7 // lsr x7, x5, x6 + WORD $0xb4ffff87 // cbz x7, LBB0_192 $-16(%rip) + WORD $0x17ffffdc // b LBB0_185 $-144(%rip) +LBB0_193: + WORD $0x52800014 // mov w20, #0 +LBB0_194: + WORD $0x4b1301ad // sub w13, w13, w19 + WORD $0x110005ad // add w13, w13, #1 + WORD $0xb5000105 // cbnz x5, LBB0_196 $32(%rip) + WORD $0x14000012 // b LBB0_198 $72(%rip) +LBB0_195: + WORD $0xf100021f // cmp x16, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x8a0700b0 // and x16, x5, x7 + WORD $0x8b100a10 // add x16, x16, x16, lsl #2 + WORD $0xd37ffa05 // lsl x5, x16, #1 + WORD $0xb4000185 // cbz x5, LBB0_198 $48(%rip) +LBB0_196: + WORD $0x9ac624b0 // lsr x16, x5, x6 + WORD $0x93407e84 // sxtw x4, w20 + WORD $0xeb04015f // cmp x10, x4 + WORD $0x54fffee9 // b.ls LBB0_195 $-36(%rip) + WORD $0x1100c210 // add w16, w16, #48 + WORD $0x38246930 // strb w16, [x9, x4] + WORD $0x11000694 // add w20, w20, #1 + WORD $0x8a0700b0 // and x16, x5, x7 + WORD $0x8b100a10 // add x16, x16, x16, lsl #2 + WORD $0xd37ffa05 // lsl x5, x16, #1 + WORD $0xb5fffec5 // cbnz x5, LBB0_196 $-40(%rip) +LBB0_198: + WORD $0x7100069f // cmp w20, #1 + WORD $0x54ffe9cb // b.lt LBB0_149 $-712(%rip) + WORD $0x2a1403f0 // mov w16, w20 + WORD $0x8b090204 // add x4, x16, x9 + WORD $0x385ff084 // ldurb w4, [x4, #-1] + WORD $0x7100c09f // cmp w4, #48 + WORD $0x54ffe941 // b.ne LBB0_150 $-728(%rip) +LBB0_200: + WORD $0xf1000604 // subs x4, x16, #1 + WORD $0x540001a9 // b.ls LBB0_204 $52(%rip) + WORD $0x51000a10 // sub w16, w16, #2 + WORD $0x38704925 // ldrb w5, [x9, w16, uxtw] + WORD $0xaa0403f0 // mov x16, x4 + WORD $0x7100c0bf // cmp w5, #48 + WORD $0x54ffff40 // b.eq LBB0_200 $-24(%rip) + WORD $0xaa0403f0 // mov x16, x4 + WORD $0xaa0403f4 // mov x20, x4 + WORD $0x17ffff42 // b LBB0_151 $-760(%rip) +LBB0_203: + WORD $0x52800010 // mov w16, #0 + WORD $0x52800014 // mov w20, #0 + WORD $0x52800004 // mov w4, #0 + WORD $0x17ffff3e // b LBB0_151 $-776(%rip) +LBB0_204: + WORD $0x51000610 // sub w16, w16, #1 +LBB0_205: + WORD $0x5280000d // mov w13, #0 + WORD $0x0b0e006e // add w14, w3, w14 + WORD $0x14000002 // b LBB0_207 $8(%rip) +LBB0_206: + WORD $0x5280000e // mov w14, #0 +LBB0_207: + WORD $0xaa1003f4 // mov x20, x16 +LBB0_208: + WORD $0x52800d11 // mov w17, #104 + WORD $0xb202e7e0 // mov x0, #-3689348814741910324 + WORD $0xf29999a0 // movk x0, #52429 + WORD $0x92800123 // mov x3, #-10 + WORD $0xb2607fe4 // mov x4, #-4294967296 + WORD $0x52800145 // mov w5, #10 + WORD $0x92800006 // mov x6, #-1 + WORD $0xaa1003f3 // mov x19, x16 + WORD $0xaa1403f5 // mov x21, x20 +Lloh10: + WORD $0x1001c010 // adr x16, _LSHIFT_TAB $14336(%rip) +Lloh11: + WORD $0x91000210 // add x16, x16, _LSHIFT_TAB@PAGEOFF $0(%rip) + WORD $0x14000002 // b LBB0_210 $8(%rip) +LBB0_209: + WORD $0x4b0701ce // sub w14, w14, w7 +LBB0_210: + WORD $0x37f800cd // tbnz w13, #31, LBB0_213 $24(%rip) + WORD $0x3500280d // cbnz w13, LBB0_300 $1280(%rip) + WORD $0x39c00127 // ldrsb w7, [x9] + WORD $0x7100d4ff // cmp w7, #53 + WORD $0x5400010b // b.lt LBB0_216 $32(%rip) + WORD $0x1400013c // b LBB0_300 $1264(%rip) +LBB0_213: + WORD $0x310021bf // cmn w13, #8 + WORD $0x540000a2 // b.hs LBB0_216 $20(%rip) + WORD $0x52800367 // mov w7, #27 + WORD $0x34001fd5 // cbz w21, LBB0_284 $1016(%rip) + WORD $0xaa1503f4 // mov x20, x21 + WORD $0x14000004 // b LBB0_217 $16(%rip) +LBB0_216: + WORD $0x4b0d03e7 // neg w7, w13 + WORD $0xb86759e7 // ldr w7, [x15, w7, uxtw #2] + WORD $0x34fffe34 // cbz w20, LBB0_209 $-60(%rip) +LBB0_217: + WORD $0x2a0703f6 // mov w22, w7 + WORD $0x9bb140f8 // umaddl x24, w7, w17, x16 + WORD $0xb8404715 // ldr w21, [x24], #4 + WORD $0x93407e97 // sxtw x23, w20 + WORD $0xaa0903f4 // mov x20, x9 + WORD $0xaa1703f9 // mov x25, x23 +LBB0_218: + WORD $0x3940031a // ldrb w26, [x24] + WORD $0x340001ba // cbz w26, LBB0_223 $52(%rip) + WORD $0x3940029b // ldrb w27, [x20] + WORD $0x6b1a037f // cmp w27, w26 + WORD $0x54000b01 // b.ne LBB0_239 $352(%rip) + WORD $0x91000694 // add x20, x20, #1 + WORD $0x91000718 // add x24, x24, #1 + WORD $0xf1000739 // subs x25, x25, #1 + WORD $0x54ffff01 // b.ne LBB0_218 $-32(%rip) + WORD $0x9b1142d4 // madd x20, x22, x17, x16 + WORD $0x8b374294 // add x20, x20, w23, uxtw + WORD $0x39401294 // ldrb w20, [x20, #4] + WORD $0x34000054 // cbz w20, LBB0_223 $8(%rip) +LBB0_222: + WORD $0x510006b5 // sub w21, w21, #1 +LBB0_223: + WORD $0x710006ff // cmp w23, #1 + WORD $0x5400070b // b.lt LBB0_233 $224(%rip) + WORD $0xd2800014 // mov x20, #0 + WORD $0x0b1702b8 // add w24, w21, w23 + WORD $0x92407ef9 // and x25, x23, #0xffffffff + WORD $0x93407f1a // sxtw x26, w24 + WORD $0x93607f17 // sbfiz x23, x24, #32, #32 + WORD $0xd100075b // sub x27, x26, #1 + WORD $0x91000738 // add x24, x25, #1 + WORD $0x14000008 // b LBB0_226 $32(%rip) +LBB0_225: + WORD $0xf100037f // cmp x27, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x8b0402f7 // add x23, x23, x4 + WORD $0xd100073b // sub x27, x25, #1 + WORD $0xd1000718 // sub x24, x24, #1 + WORD $0xf100071f // cmp x24, #1 + WORD $0x54000269 // b.ls LBB0_228 $76(%rip) +LBB0_226: + WORD $0xaa1b03f9 // mov x25, x27 + WORD $0x51000b1a // sub w26, w24, #2 + WORD $0x38ba493a // ldrsb x26, [x9, w26, uxtw] + WORD $0xd100c35a // sub x26, x26, #48 + WORD $0x9ad6235a // lsl x26, x26, x22 + WORD $0x8b14035a // add x26, x26, x20 + WORD $0x9bc07f54 // umulh x20, x26, x0 + WORD $0xd343fe94 // lsr x20, x20, #3 + WORD $0x9b036a9b // madd x27, x20, x3, x26 + WORD $0xeb0a033f // cmp x25, x10 + WORD $0x54fffde2 // b.hs LBB0_225 $-68(%rip) + WORD $0x1100c37b // add w27, w27, #48 + WORD $0x3839693b // strb w27, [x9, x25] + WORD $0x8b0402f7 // add x23, x23, x4 + WORD $0xd100073b // sub x27, x25, #1 + WORD $0xd1000718 // sub x24, x24, #1 + WORD $0xf100071f // cmp x24, #1 + WORD $0x54fffde8 // b.hi LBB0_226 $-68(%rip) +LBB0_228: + WORD $0xf1002b5f // cmp x26, #10 + WORD $0x540002a3 // b.lo LBB0_233 $84(%rip) + WORD $0x93407f36 // sxtw x22, w25 + WORD $0xd10006d6 // sub x22, x22, #1 + WORD $0x14000007 // b LBB0_231 $28(%rip) +LBB0_230: + WORD $0xf100031f // cmp x24, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0xd10006d6 // sub x22, x22, #1 + WORD $0xf100269f // cmp x20, #9 + WORD $0xaa1703f4 // mov x20, x23 + WORD $0x54000189 // b.ls LBB0_233 $48(%rip) +LBB0_231: + WORD $0x9bc07e97 // umulh x23, x20, x0 + WORD $0xd343fef7 // lsr x23, x23, #3 + WORD $0x9b0352f8 // madd x24, x23, x3, x20 + WORD $0xeb0a02df // cmp x22, x10 + WORD $0x54fffec2 // b.hs LBB0_230 $-40(%rip) + WORD $0x1100c318 // add w24, w24, #48 + WORD $0x38366938 // strb w24, [x9, x22] + WORD $0xd10006d6 // sub x22, x22, #1 + WORD $0xf100269f // cmp x20, #9 + WORD $0xaa1703f4 // mov x20, x23 + WORD $0x54fffec8 // b.hi LBB0_231 $-40(%rip) +LBB0_233: + WORD $0x0b1302b3 // add w19, w21, w19 + WORD $0xeb33c15f // cmp x10, w19, sxtw + WORD $0x1a8a8273 // csel w19, w19, w10, hi + WORD $0x0b0d02ad // add w13, w21, w13 + WORD $0x7100067f // cmp w19, #1 + WORD $0x540001cb // b.lt LBB0_238 $56(%rip) + WORD $0x8b090274 // add x20, x19, x9 + WORD $0x385ff294 // ldurb w20, [x20, #-1] + WORD $0x7100c29f // cmp w20, #48 + WORD $0x54000241 // b.ne LBB0_242 $72(%rip) +LBB0_235: + WORD $0xf1000674 // subs x20, x19, #1 + WORD $0x540001c9 // b.ls LBB0_240 $56(%rip) + WORD $0x51000a73 // sub w19, w19, #2 + WORD $0x38734935 // ldrb w21, [x9, w19, uxtw] + WORD $0xaa1403f3 // mov x19, x20 + WORD $0x7100c2bf // cmp w21, #48 + WORD $0x54ffff40 // b.eq LBB0_235 $-24(%rip) + WORD $0xaa1403f3 // mov x19, x20 + WORD $0x14000009 // b LBB0_242 $36(%rip) +LBB0_238: + WORD $0x35000113 // cbnz w19, LBB0_242 $32(%rip) + WORD $0x14000006 // b LBB0_241 $24(%rip) +LBB0_239: + WORD $0x13001f74 // sxtb w20, w27 + WORD $0x6b3a829f // cmp w20, w26, sxtb + WORD $0x54fff5eb // b.lt LBB0_222 $-324(%rip) + WORD $0x17ffffaf // b LBB0_223 $-324(%rip) +LBB0_240: + WORD $0x51000673 // sub w19, w19, #1 +LBB0_241: + WORD $0x5280000d // mov w13, #0 +LBB0_242: + WORD $0x37f800a7 // tbnz w7, #31, LBB0_244 $20(%rip) +LBB0_243: + WORD $0xaa1303f5 // mov x21, x19 + WORD $0xaa1303f4 // mov x20, x19 + WORD $0x4b0701ce // sub w14, w14, w7 + WORD $0x17ffff85 // b LBB0_210 $-492(%rip) +LBB0_244: + WORD $0x3100f4ff // cmn w7, #61 + WORD $0x54000ac8 // b.hi LBB0_271 $344(%rip) + WORD $0xaa0703f4 // mov x20, x7 + WORD $0x14000007 // b LBB0_249 $28(%rip) +LBB0_246: + WORD $0x5280000d // mov w13, #0 +LBB0_247: + WORD $0x52800013 // mov w19, #0 +LBB0_248: + WORD $0x1100f297 // add w23, w20, #60 + WORD $0x3101e29f // cmn w20, #120 + WORD $0xaa1703f4 // mov x20, x23 + WORD $0x540009ea // b.ge LBB0_272 $316(%rip) +LBB0_249: + WORD $0xd2800017 // mov x23, #0 + WORD $0xd2800015 // mov x21, #0 + WORD $0x7100027f // cmp w19, #0 + WORD $0x1a9fc276 // csel w22, w19, wzr, gt +LBB0_250: + WORD $0xeb1702df // cmp x22, x23 + WORD $0x54000120 // b.eq LBB0_253 $36(%rip) + WORD $0x38b76938 // ldrsb x24, [x9, x23] + WORD $0x9b0562b5 // madd x21, x21, x5, x24 + WORD $0xd100c2b5 // sub x21, x21, #48 + WORD $0x910006f7 // add x23, x23, #1 + WORD $0xd37cfeb8 // lsr x24, x21, #60 + WORD $0xb4ffff38 // cbz x24, LBB0_250 $-28(%rip) + WORD $0xaa1703f6 // mov x22, x23 + WORD $0x14000007 // b LBB0_255 $28(%rip) +LBB0_253: + WORD $0xb4fffdb5 // cbz x21, LBB0_247 $-76(%rip) +LBB0_254: + WORD $0x8b150ab7 // add x23, x21, x21, lsl #2 + WORD $0xd37ffaf5 // lsl x21, x23, #1 + WORD $0x110006d6 // add w22, w22, #1 + WORD $0xd37bfaf7 // ubfx x23, x23, #59, #4 + WORD $0xb4ffff97 // cbz x23, LBB0_254 $-16(%rip) +LBB0_255: + WORD $0x4b1601ad // sub w13, w13, w22 + WORD $0x6b1302df // cmp w22, w19 + WORD $0x5400024a // b.ge LBB0_260 $72(%rip) + WORD $0x93407ed6 // sxtw x22, w22 + WORD $0x93407e77 // sxtw x23, w19 + WORD $0xcb1602f3 // sub x19, x23, x22 + WORD $0xaa0903f8 // mov x24, x9 +LBB0_257: + WORD $0xd37cfeb9 // lsr x25, x21, #60 + WORD $0x321c0739 // orr w25, w25, #0x30 + WORD $0x39000319 // strb w25, [x24] + WORD $0x38b66b19 // ldrsb x25, [x24, x22] + WORD $0x9240eeb5 // and x21, x21, #0xfffffffffffffff + WORD $0x9b0566b5 // madd x21, x21, x5, x25 + WORD $0xd100c2b5 // sub x21, x21, #48 + WORD $0x91000718 // add x24, x24, #1 + WORD $0xd10006f7 // sub x23, x23, #1 + WORD $0xeb1702df // cmp x22, x23 + WORD $0x54fffec1 // b.ne LBB0_257 $-40(%rip) + WORD $0xb5000075 // cbnz x21, LBB0_261 $12(%rip) + WORD $0x14000014 // b LBB0_265 $80(%rip) +LBB0_260: + WORD $0x52800013 // mov w19, #0 +LBB0_261: + WORD $0x14000007 // b LBB0_263 $28(%rip) +LBB0_262: + WORD $0xf10002ff // cmp x23, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x9240eeb6 // and x22, x21, #0xfffffffffffffff + WORD $0x8b160ad5 // add x21, x22, x22, lsl #2 + WORD $0xd37ffab5 // lsl x21, x21, #1 + WORD $0xb4000196 // cbz x22, LBB0_265 $48(%rip) +LBB0_263: + WORD $0x93407e76 // sxtw x22, w19 + WORD $0xd37cfeb7 // lsr x23, x21, #60 + WORD $0xeb16015f // cmp x10, x22 + WORD $0x54fffee9 // b.ls LBB0_262 $-36(%rip) + WORD $0x321c06f7 // orr w23, w23, #0x30 + WORD $0x38366937 // strb w23, [x9, x22] + WORD $0x11000673 // add w19, w19, #1 + WORD $0x9240eeb6 // and x22, x21, #0xfffffffffffffff + WORD $0x8b160ad5 // add x21, x22, x22, lsl #2 + WORD $0xd37ffab5 // lsl x21, x21, #1 + WORD $0xb5fffed6 // cbnz x22, LBB0_263 $-40(%rip) +LBB0_265: + WORD $0x110005ad // add w13, w13, #1 + WORD $0x7100067f // cmp w19, #1 + WORD $0x540001cb // b.lt LBB0_270 $56(%rip) + WORD $0x2a1303f5 // mov w21, w19 + WORD $0x8b0902b6 // add x22, x21, x9 + WORD $0x385ff2d6 // ldurb w22, [x22, #-1] + WORD $0x7100c2df // cmp w22, #48 + WORD $0x54fff741 // b.ne LBB0_248 $-280(%rip) +LBB0_267: + WORD $0xf10006b3 // subs x19, x21, #1 + WORD $0x54fff6c9 // b.ls LBB0_246 $-296(%rip) + WORD $0x51000ab5 // sub w21, w21, #2 + WORD $0x38754936 // ldrb w22, [x9, w21, uxtw] + WORD $0xaa1303f5 // mov x21, x19 + WORD $0x7100c2df // cmp w22, #48 + WORD $0x54ffff40 // b.eq LBB0_267 $-24(%rip) + WORD $0x17ffffb2 // b LBB0_248 $-312(%rip) +LBB0_270: + WORD $0x35fff633 // cbnz w19, LBB0_248 $-316(%rip) + WORD $0x17ffffae // b LBB0_246 $-328(%rip) +LBB0_271: + WORD $0xaa0703f7 // mov x23, x7 +LBB0_272: + WORD $0xd2800015 // mov x21, #0 + WORD $0xd2800016 // mov x22, #0 + WORD $0x4b1703f4 // neg w20, w23 + WORD $0x7100027f // cmp w19, #0 + WORD $0x1a9fc278 // csel w24, w19, wzr, gt +LBB0_273: + WORD $0xeb15031f // cmp x24, x21 + WORD $0x540003c0 // b.eq LBB0_280 $120(%rip) + WORD $0x38b56937 // ldrsb x23, [x9, x21] + WORD $0x9b055ed6 // madd x22, x22, x5, x23 + WORD $0xd100c2d6 // sub x22, x22, #48 + WORD $0x910006b5 // add x21, x21, #1 + WORD $0x9ad426d7 // lsr x23, x22, x20 + WORD $0xb4ffff37 // cbz x23, LBB0_273 $-28(%rip) + WORD $0xaa1503f8 // mov x24, x21 +LBB0_276: + WORD $0x9ad420d5 // lsl x21, x6, x20 + WORD $0xaa3503f7 // mvn x23, x21 + WORD $0x6b13031f // cmp w24, w19 + WORD $0x540004aa // b.ge LBB0_285 $148(%rip) + WORD $0xaa1803f5 // mov x21, x24 + WORD $0x93407eb5 // sxtw x21, w21 + WORD $0x93407e79 // sxtw x25, w19 + WORD $0xcb150333 // sub x19, x25, x21 + WORD $0xaa0903fa // mov x26, x9 +LBB0_278: + WORD $0x9ad426db // lsr x27, x22, x20 + WORD $0x1100c37b // add w27, w27, #48 + WORD $0x3900035b // strb w27, [x26] + WORD $0x38b56b5b // ldrsb x27, [x26, x21] + WORD $0x8a1702d6 // and x22, x22, x23 + WORD $0x9b056ed6 // madd x22, x22, x5, x27 + WORD $0xd100c2d6 // sub x22, x22, #48 + WORD $0x9100075a // add x26, x26, #1 + WORD $0xd1000739 // sub x25, x25, #1 + WORD $0xeb1902bf // cmp x21, x25 + WORD $0x54fffec1 // b.ne LBB0_278 $-40(%rip) + WORD $0xaa1303f5 // mov x21, x19 + WORD $0x14000014 // b LBB0_286 $80(%rip) +LBB0_280: + WORD $0xb40007d6 // cbz x22, LBB0_297 $248(%rip) + WORD $0x9ad426d5 // lsr x21, x22, x20 + WORD $0xb40000f5 // cbz x21, LBB0_283 $28(%rip) + WORD $0x52800015 // mov w21, #0 + WORD $0x9ad420d3 // lsl x19, x6, x20 + WORD $0xaa3303f7 // mvn x23, x19 + WORD $0x4b1801ad // sub w13, w13, w24 + WORD $0x110005ad // add w13, w13, #1 + WORD $0x14000015 // b LBB0_288 $84(%rip) +LBB0_283: + WORD $0x8b160ad5 // add x21, x22, x22, lsl #2 + WORD $0xd37ffab6 // lsl x22, x21, #1 + WORD $0x11000718 // add w24, w24, #1 + WORD $0x9ad426d5 // lsr x21, x22, x20 + WORD $0xb4ffff95 // cbz x21, LBB0_283 $-16(%rip) + WORD $0x17ffffdc // b LBB0_276 $-144(%rip) +LBB0_284: + WORD $0x52800014 // mov w20, #0 + WORD $0x4b0701ce // sub w14, w14, w7 + WORD $0x17fffef7 // b LBB0_210 $-1060(%rip) +LBB0_285: + WORD $0x52800015 // mov w21, #0 +LBB0_286: + WORD $0x4b1801ad // sub w13, w13, w24 + WORD $0x110005ad // add w13, w13, #1 + WORD $0xb5000116 // cbnz x22, LBB0_288 $32(%rip) + WORD $0x14000012 // b LBB0_290 $72(%rip) +LBB0_287: + WORD $0xf100027f // cmp x19, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x8a1702d3 // and x19, x22, x23 + WORD $0x8b130a73 // add x19, x19, x19, lsl #2 + WORD $0xd37ffa76 // lsl x22, x19, #1 + WORD $0xb4000196 // cbz x22, LBB0_290 $48(%rip) +LBB0_288: + WORD $0x9ad426d3 // lsr x19, x22, x20 + WORD $0x93407eb8 // sxtw x24, w21 + WORD $0xeb18015f // cmp x10, x24 + WORD $0x54fffee9 // b.ls LBB0_287 $-36(%rip) + WORD $0x1100c273 // add w19, w19, #48 + WORD $0x38386933 // strb w19, [x9, x24] + WORD $0x110006b5 // add w21, w21, #1 + WORD $0x8a1702d3 // and x19, x22, x23 + WORD $0x8b130a73 // add x19, x19, x19, lsl #2 + WORD $0xd37ffa76 // lsl x22, x19, #1 + WORD $0xb5fffed6 // cbnz x22, LBB0_288 $-40(%rip) +LBB0_290: + WORD $0x710006bf // cmp w21, #1 + WORD $0x5400020b // b.lt LBB0_295 $64(%rip) + WORD $0x2a1503f3 // mov w19, w21 + WORD $0x8b090274 // add x20, x19, x9 + WORD $0x385ff294 // ldurb w20, [x20, #-1] + WORD $0x7100c29f // cmp w20, #48 + WORD $0x54000181 // b.ne LBB0_296 $48(%rip) +LBB0_292: + WORD $0xf1000674 // subs x20, x19, #1 + WORD $0x54000269 // b.ls LBB0_298 $76(%rip) + WORD $0x51000a73 // sub w19, w19, #2 + WORD $0x38734935 // ldrb w21, [x9, w19, uxtw] + WORD $0xaa1403f3 // mov x19, x20 + WORD $0x7100c2bf // cmp w21, #48 + WORD $0x54ffff40 // b.eq LBB0_292 $-24(%rip) + WORD $0xaa1403f3 // mov x19, x20 + WORD $0xaa1403f5 // mov x21, x20 + WORD $0x17fffecf // b LBB0_209 $-1220(%rip) +LBB0_295: + WORD $0x340001b5 // cbz w21, LBB0_299 $52(%rip) +LBB0_296: + WORD $0xaa1503f3 // mov x19, x21 + WORD $0xaa1503f4 // mov x20, x21 + WORD $0x4b0701ce // sub w14, w14, w7 + WORD $0x17fffecb // b LBB0_210 $-1236(%rip) +LBB0_297: + WORD $0x52800013 // mov w19, #0 + WORD $0x52800015 // mov w21, #0 + WORD $0x52800014 // mov w20, #0 + WORD $0x4b0701ce // sub w14, w14, w7 + WORD $0x17fffec6 // b LBB0_210 $-1256(%rip) +LBB0_298: + WORD $0x51000673 // sub w19, w19, #1 + WORD $0x5280000d // mov w13, #0 + WORD $0x17ffff3b // b LBB0_243 $-788(%rip) +LBB0_299: + WORD $0x52800013 // mov w19, #0 + WORD $0x5280000d // mov w13, #0 + WORD $0x17ffff38 // b LBB0_243 $-800(%rip) +LBB0_300: + WORD $0x310ff9df // cmn w14, #1022 + WORD $0x54000bac // b.gt LBB0_327 $372(%rip) + WORD $0x34001334 // cbz w20, LBB0_342 $612(%rip) + WORD $0x110ff5cf // add w15, w14, #1021 + WORD $0x3110e9df // cmn w14, #1082 + WORD $0x54000ba8 // b.hi LBB0_329 $372(%rip) + WORD $0x5280014e // mov w14, #10 + WORD $0x14000009 // b LBB0_307 $36(%rip) +LBB0_304: + WORD $0x5280000d // mov w13, #0 +LBB0_305: + WORD $0x52800013 // mov w19, #0 +LBB0_306: + WORD $0x1100f1e0 // add w0, w15, #60 + WORD $0xaa1303f4 // mov x20, x19 + WORD $0xaa1303e3 // mov x3, x19 + WORD $0x3101e1ff // cmn w15, #120 + WORD $0xaa0003ef // mov x15, x0 + WORD $0x54000aaa // b.ge LBB0_330 $340(%rip) +LBB0_307: + WORD $0xd2800003 // mov x3, #0 + WORD $0xd2800011 // mov x17, #0 + WORD $0x7100029f // cmp w20, #0 + WORD $0x1a9fc280 // csel w0, w20, wzr, gt +LBB0_308: + WORD $0xeb03001f // cmp x0, x3 + WORD $0x54000120 // b.eq LBB0_311 $36(%rip) + WORD $0x38a36924 // ldrsb x4, [x9, x3] + WORD $0x9b0e1231 // madd x17, x17, x14, x4 + WORD $0xd100c231 // sub x17, x17, #48 + WORD $0x91000463 // add x3, x3, #1 + WORD $0xd37cfe24 // lsr x4, x17, #60 + WORD $0xb4ffff24 // cbz x4, LBB0_308 $-28(%rip) + WORD $0xaa0303e0 // mov x0, x3 + WORD $0x14000007 // b LBB0_313 $28(%rip) +LBB0_311: + WORD $0xb4fffd71 // cbz x17, LBB0_305 $-84(%rip) +LBB0_312: + WORD $0x8b110a23 // add x3, x17, x17, lsl #2 + WORD $0xd37ff871 // lsl x17, x3, #1 + WORD $0x11000400 // add w0, w0, #1 + WORD $0xd37bf863 // ubfx x3, x3, #59, #4 + WORD $0xb4ffff83 // cbz x3, LBB0_312 $-16(%rip) +LBB0_313: + WORD $0x4b0001ad // sub w13, w13, w0 + WORD $0x6b14001f // cmp w0, w20 + WORD $0x5400026a // b.ge LBB0_317 $76(%rip) + WORD $0xd2800003 // mov x3, #0 + WORD $0x93407c00 // sxtw x0, w0 + WORD $0x93407e64 // sxtw x4, w19 + WORD $0x8b000125 // add x5, x9, x0 +LBB0_315: + WORD $0xd37cfe26 // lsr x6, x17, #60 + WORD $0x321c04c6 // orr w6, w6, #0x30 + WORD $0x38236926 // strb w6, [x9, x3] + WORD $0x38a368a6 // ldrsb x6, [x5, x3] + WORD $0x9240ee31 // and x17, x17, #0xfffffffffffffff + WORD $0x91000463 // add x3, x3, #1 + WORD $0x9b0e1a31 // madd x17, x17, x14, x6 + WORD $0xd100c231 // sub x17, x17, #48 + WORD $0x8b030006 // add x6, x0, x3 + WORD $0xeb0400df // cmp x6, x4 + WORD $0x54fffecb // b.lt LBB0_315 $-40(%rip) + WORD $0xaa0303f3 // mov x19, x3 + WORD $0xb5000151 // cbnz x17, LBB0_319 $40(%rip) + WORD $0x14000014 // b LBB0_321 $80(%rip) +LBB0_317: + WORD $0x52800013 // mov w19, #0 + WORD $0x14000007 // b LBB0_319 $28(%rip) +LBB0_318: + WORD $0xf100007f // cmp x3, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x9240ee20 // and x0, x17, #0xfffffffffffffff + WORD $0x8b000811 // add x17, x0, x0, lsl #2 + WORD $0xd37ffa31 // lsl x17, x17, #1 + WORD $0xb4000180 // cbz x0, LBB0_321 $48(%rip) +LBB0_319: + WORD $0x93407e60 // sxtw x0, w19 + WORD $0xd37cfe23 // lsr x3, x17, #60 + WORD $0xeb00015f // cmp x10, x0 + WORD $0x54fffee9 // b.ls LBB0_318 $-36(%rip) + WORD $0x321c0463 // orr w3, w3, #0x30 + WORD $0x38206923 // strb w3, [x9, x0] + WORD $0x11000673 // add w19, w19, #1 + WORD $0x9240ee20 // and x0, x17, #0xfffffffffffffff + WORD $0x8b000811 // add x17, x0, x0, lsl #2 + WORD $0xd37ffa31 // lsl x17, x17, #1 + WORD $0xb5fffec0 // cbnz x0, LBB0_319 $-40(%rip) +LBB0_321: + WORD $0x110005ad // add w13, w13, #1 + WORD $0x7100067f // cmp w19, #1 + WORD $0x540001cb // b.lt LBB0_326 $56(%rip) + WORD $0x2a1303f1 // mov w17, w19 + WORD $0x8b090220 // add x0, x17, x9 + WORD $0x385ff000 // ldurb w0, [x0, #-1] + WORD $0x7100c01f // cmp w0, #48 + WORD $0x54fff6e1 // b.ne LBB0_306 $-292(%rip) +LBB0_323: + WORD $0xf1000633 // subs x19, x17, #1 + WORD $0x54fff669 // b.ls LBB0_304 $-308(%rip) + WORD $0x51000a31 // sub w17, w17, #2 + WORD $0x38714920 // ldrb w0, [x9, w17, uxtw] + WORD $0xaa1303f1 // mov x17, x19 + WORD $0x7100c01f // cmp w0, #48 + WORD $0x54ffff40 // b.eq LBB0_323 $-24(%rip) + WORD $0x17ffffaf // b LBB0_306 $-324(%rip) +LBB0_326: + WORD $0x35fff5d3 // cbnz w19, LBB0_306 $-328(%rip) + WORD $0x17ffffab // b LBB0_304 $-340(%rip) +LBB0_327: + WORD $0x711001df // cmp w14, #1024 + WORD $0x54ffaccc // b.gt LBB0_139 $-2664(%rip) + WORD $0x510005ce // sub w14, w14, #1 + WORD $0x1400006d // b LBB0_357 $436(%rip) +LBB0_329: + WORD $0xaa1403e3 // mov x3, x20 + WORD $0xaa0f03e0 // mov x0, x15 +LBB0_330: + WORD $0xd2800011 // mov x17, #0 + WORD $0xd280000e // mov x14, #0 + WORD $0x4b0003ef // neg w15, w0 + WORD $0x7100007f // cmp w3, #0 + WORD $0x1a9fc060 // csel w0, w3, wzr, gt + WORD $0x52800144 // mov w4, #10 +LBB0_331: + WORD $0xeb11001f // cmp x0, x17 + WORD $0x54000400 // b.eq LBB0_338 $128(%rip) + WORD $0x38b16925 // ldrsb x5, [x9, x17] + WORD $0x9b0415ce // madd x14, x14, x4, x5 + WORD $0xd100c1ce // sub x14, x14, #48 + WORD $0x91000631 // add x17, x17, #1 + WORD $0x9acf25c5 // lsr x5, x14, x15 + WORD $0xb4ffff25 // cbz x5, LBB0_331 $-28(%rip) + WORD $0xaa1103e0 // mov x0, x17 +LBB0_334: + WORD $0x92800011 // mov x17, #-1 + WORD $0x9acf2231 // lsl x17, x17, x15 + WORD $0xaa3103f1 // mvn x17, x17 + WORD $0x6b03001f // cmp w0, w3 + WORD $0x540004ea // b.ge LBB0_343 $156(%rip) + WORD $0xd2800006 // mov x6, #0 + WORD $0xaa0003e3 // mov x3, x0 + WORD $0x93407c63 // sxtw x3, w3 + WORD $0x93407e64 // sxtw x4, w19 + WORD $0x8b030125 // add x5, x9, x3 + WORD $0x52800147 // mov w7, #10 +LBB0_336: + WORD $0x9acf25d3 // lsr x19, x14, x15 + WORD $0x1100c273 // add w19, w19, #48 + WORD $0x38266933 // strb w19, [x9, x6] + WORD $0x38a668b3 // ldrsb x19, [x5, x6] + WORD $0x8a1101ce // and x14, x14, x17 + WORD $0x910004c6 // add x6, x6, #1 + WORD $0x9b074dce // madd x14, x14, x7, x19 + WORD $0xd100c1ce // sub x14, x14, #48 + WORD $0x8b060073 // add x19, x3, x6 + WORD $0xeb04027f // cmp x19, x4 + WORD $0x54fffecb // b.lt LBB0_336 $-40(%rip) + WORD $0xaa0603f3 // mov x19, x6 + WORD $0x14000015 // b LBB0_344 $84(%rip) +LBB0_338: + WORD $0xb400020e // cbz x14, LBB0_342 $64(%rip) + WORD $0x9acf25d1 // lsr x17, x14, x15 + WORD $0xb4000111 // cbz x17, LBB0_341 $32(%rip) + WORD $0x52800013 // mov w19, #0 + WORD $0x92800011 // mov x17, #-1 + WORD $0x9acf2231 // lsl x17, x17, x15 + WORD $0xaa3103f1 // mvn x17, x17 + WORD $0x4b0001ad // sub w13, w13, w0 + WORD $0x110005ad // add w13, w13, #1 + WORD $0x14000015 // b LBB0_346 $84(%rip) +LBB0_341: + WORD $0x8b0e09ce // add x14, x14, x14, lsl #2 + WORD $0xd37ff9ce // lsl x14, x14, #1 + WORD $0x11000400 // add w0, w0, #1 + WORD $0x9acf25d1 // lsr x17, x14, x15 + WORD $0xb4ffff91 // cbz x17, LBB0_341 $-16(%rip) + WORD $0x17ffffd9 // b LBB0_334 $-156(%rip) +LBB0_342: + WORD $0x5280000a // mov w10, #0 + WORD $0x12807fae // mov w14, #-1022 + WORD $0x1400009a // b LBB0_384 $616(%rip) +LBB0_343: + WORD $0x52800013 // mov w19, #0 +LBB0_344: + WORD $0x4b0001ad // sub w13, w13, w0 + WORD $0x110005ad // add w13, w13, #1 + WORD $0xb500010e // cbnz x14, LBB0_346 $32(%rip) + WORD $0x14000012 // b LBB0_348 $72(%rip) +LBB0_345: + WORD $0xf100001f // cmp x0, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0x8a1101ce // and x14, x14, x17 + WORD $0x8b0e09ce // add x14, x14, x14, lsl #2 + WORD $0xd37ff9ce // lsl x14, x14, #1 + WORD $0xb400018e // cbz x14, LBB0_348 $48(%rip) +LBB0_346: + WORD $0x9acf25c0 // lsr x0, x14, x15 + WORD $0x93407e63 // sxtw x3, w19 + WORD $0xeb03015f // cmp x10, x3 + WORD $0x54fffee9 // b.ls LBB0_345 $-36(%rip) + WORD $0x1100c000 // add w0, w0, #48 + WORD $0x38236920 // strb w0, [x9, x3] + WORD $0x11000673 // add w19, w19, #1 + WORD $0x8a1101ce // and x14, x14, x17 + WORD $0x8b0e09ce // add x14, x14, x14, lsl #2 + WORD $0xd37ff9ce // lsl x14, x14, #1 + WORD $0xb5fffece // cbnz x14, LBB0_346 $-40(%rip) +LBB0_348: + WORD $0x7100067f // cmp w19, #1 + WORD $0x540001cb // b.lt LBB0_352 $56(%rip) + WORD $0x2a1303ef // mov w15, w19 + WORD $0x8b0901ee // add x14, x15, x9 + WORD $0x385ff1ce // ldurb w14, [x14, #-1] + WORD $0x7100c1df // cmp w14, #48 + WORD $0x540001a1 // b.ne LBB0_354 $52(%rip) +LBB0_350: + WORD $0xaa0f03ee // mov x14, x15 + WORD $0xf10005ef // subs x15, x15, #1 + WORD $0x540001a9 // b.ls LBB0_355 $52(%rip) + WORD $0x510009d1 // sub w17, w14, #2 + WORD $0x38714931 // ldrb w17, [x9, w17, uxtw] + WORD $0x7100c23f // cmp w17, #48 + WORD $0x54ffff40 // b.eq LBB0_350 $-24(%rip) + WORD $0x14000009 // b LBB0_356 $36(%rip) +LBB0_352: + WORD $0x12807fae // mov w14, #-1022 + WORD $0x34001933 // cbz w19, LBB0_410 $804(%rip) + WORD $0xaa1303f4 // mov x20, x19 + WORD $0x14000009 // b LBB0_359 $36(%rip) +LBB0_354: + WORD $0x12807fae // mov w14, #-1022 + WORD $0xaa1303f4 // mov x20, x19 + WORD $0x14000006 // b LBB0_359 $24(%rip) +LBB0_355: + WORD $0x5280000d // mov w13, #0 +LBB0_356: + WORD $0x510005d3 // sub w19, w14, #1 + WORD $0x12807fae // mov w14, #-1022 + WORD $0xaa1303f4 // mov x20, x19 +LBB0_357: + WORD $0x34000294 // cbz w20, LBB0_365 $80(%rip) +LBB0_359: + WORD $0xd280000f // mov x15, #0 + WORD $0x93407e91 // sxtw x17, w20 + WORD $0x5282b180 // mov w0, #5516 +LBB0_360: + WORD $0xf10099ff // cmp x15, #38 + WORD $0x54000280 // b.eq LBB0_367 $80(%rip) + WORD $0x8b0f0203 // add x3, x16, x15 + WORD $0x38e06863 // ldrsb w3, [x3, x0] + WORD $0x386f6924 // ldrb w4, [x9, x15] + WORD $0x6b23009f // cmp w4, w3, uxtb + WORD $0x54000181 // b.ne LBB0_366 $48(%rip) + WORD $0x910005ef // add x15, x15, #1 + WORD $0xeb0f023f // cmp x17, x15 + WORD $0x54fffee1 // b.ne LBB0_360 $-36(%rip) + WORD $0x8b31420f // add x15, x16, w17, uxtw + WORD $0x5282b190 // mov w16, #5516 + WORD $0x387069ef // ldrb w15, [x15, x16] + WORD $0x3400010f // cbz w15, LBB0_367 $32(%rip) +LBB0_364: + WORD $0x528001ef // mov w15, #15 + WORD $0x14000007 // b LBB0_368 $28(%rip) +LBB0_365: + WORD $0x5280000a // mov w10, #0 + WORD $0x14000054 // b LBB0_384 $336(%rip) +LBB0_366: + WORD $0x13001c8f // sxtb w15, w4 + WORD $0x6b0301ff // cmp w15, w3 + WORD $0x54ffff4b // b.lt LBB0_364 $-24(%rip) +LBB0_367: + WORD $0x5280020f // mov w15, #16 +LBB0_368: + WORD $0x7100063f // cmp w17, #1 + WORD $0x5400074b // b.lt LBB0_378 $232(%rip) + WORD $0xd2800010 // mov x16, #0 + WORD $0x0b1101e0 // add w0, w15, w17 + WORD $0x92407e31 // and x17, x17, #0xffffffff + WORD $0x93407c00 // sxtw x0, w0 + WORD $0xd1000400 // sub x0, x0, #1 + WORD $0xd2ff4003 // mov x3, #-432345564227567616 + WORD $0xb202e7e4 // mov x4, #-3689348814741910324 + WORD $0xf29999a4 // movk x4, #52429 + WORD $0x92800125 // mov x5, #-10 + WORD $0x14000007 // b LBB0_371 $28(%rip) +LBB0_370: + WORD $0xf10000ff // cmp x7, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0xd1000400 // sub x0, x0, #1 + WORD $0x91000627 // add x7, x17, #1 + WORD $0xf10004ff // cmp x7, #1 + WORD $0x54000209 // b.ls LBB0_373 $64(%rip) +LBB0_371: + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0x38b14926 // ldrsb x6, [x9, w17, uxtw] + WORD $0x8b06d610 // add x16, x16, x6, lsl #53 + WORD $0x8b030206 // add x6, x16, x3 + WORD $0x9bc47cd0 // umulh x16, x6, x4 + WORD $0xd343fe10 // lsr x16, x16, #3 + WORD $0x9b051a07 // madd x7, x16, x5, x6 + WORD $0xeb0a001f // cmp x0, x10 + WORD $0x54fffe42 // b.hs LBB0_370 $-56(%rip) + WORD $0x1100c0e7 // add w7, w7, #48 + WORD $0x38206927 // strb w7, [x9, x0] + WORD $0xd1000400 // sub x0, x0, #1 + WORD $0x91000627 // add x7, x17, #1 + WORD $0xf10004ff // cmp x7, #1 + WORD $0x54fffe48 // b.hi LBB0_371 $-56(%rip) +LBB0_373: + WORD $0xf10028df // cmp x6, #10 + WORD $0x54000323 // b.lo LBB0_378 $100(%rip) + WORD $0x8b2f4231 // add x17, x17, w15, uxtw + WORD $0x93407e31 // sxtw x17, w17 + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0xb202e7e0 // mov x0, #-3689348814741910324 + WORD $0xf29999a0 // movk x0, #52429 + WORD $0x92800123 // mov x3, #-10 + WORD $0x14000007 // b LBB0_376 $28(%rip) +LBB0_375: + WORD $0xf10000bf // cmp x5, #0 + WORD $0x1a9f058c // csinc w12, w12, wzr, eq + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0xf100261f // cmp x16, #9 + WORD $0xaa0403f0 // mov x16, x4 + WORD $0x54000189 // b.ls LBB0_378 $48(%rip) +LBB0_376: + WORD $0x9bc07e04 // umulh x4, x16, x0 + WORD $0xd343fc84 // lsr x4, x4, #3 + WORD $0x9b034085 // madd x5, x4, x3, x16 + WORD $0xeb0a023f // cmp x17, x10 + WORD $0x54fffec2 // b.hs LBB0_375 $-40(%rip) + WORD $0x1100c0a5 // add w5, w5, #48 + WORD $0x38316925 // strb w5, [x9, x17] + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0xf100261f // cmp x16, #9 + WORD $0xaa0403f0 // mov x16, x4 + WORD $0x54fffec8 // b.hi LBB0_376 $-40(%rip) +LBB0_378: + WORD $0x0b1301f0 // add w16, w15, w19 + WORD $0xeb30c15f // cmp x10, w16, sxtw + WORD $0x1a8a820a // csel w10, w16, w10, hi + WORD $0x0b0d01ed // add w13, w15, w13 + WORD $0x7100055f // cmp w10, #1 + WORD $0x540001cb // b.lt LBB0_383 $56(%rip) + WORD $0x8b09014f // add x15, x10, x9 + WORD $0x385ff1ef // ldurb w15, [x15, #-1] + WORD $0x7100c1ff // cmp w15, #48 + WORD $0x54000161 // b.ne LBB0_384 $44(%rip) +LBB0_380: + WORD $0xf100054f // subs x15, x10, #1 + WORD $0x54000789 // b.ls LBB0_400 $240(%rip) + WORD $0x5100094a // sub w10, w10, #2 + WORD $0x386a4930 // ldrb w16, [x9, w10, uxtw] + WORD $0xaa0f03ea // mov x10, x15 + WORD $0x7100c21f // cmp w16, #48 + WORD $0x54ffff40 // b.eq LBB0_380 $-24(%rip) + WORD $0xaa0f03ea // mov x10, x15 + WORD $0x14000002 // b LBB0_384 $8(%rip) +LBB0_383: + WORD $0x3400098a // cbz w10, LBB0_406 $304(%rip) +LBB0_384: + WORD $0x710051bf // cmp w13, #20 + WORD $0x5400006d // b.le LBB0_386 $12(%rip) + WORD $0x92800009 // mov x9, #-1 + WORD $0x14000054 // b LBB0_411 $336(%rip) +LBB0_386: + WORD $0x710005bf // cmp w13, #1 + WORD $0x5400028b // b.lt LBB0_391 $80(%rip) + WORD $0xd280000f // mov x15, #0 + WORD $0x7100015f // cmp w10, #0 + WORD $0x1a9fc151 // csel w17, w10, wzr, gt + WORD $0x2a0d03e0 // mov w0, w13 + WORD $0xd1000410 // sub x16, x0, #1 + WORD $0xeb11021f // cmp x16, x17 + WORD $0x9a913210 // csel x16, x16, x17, lo + WORD $0x91000603 // add x3, x16, #1 + WORD $0x52800144 // mov w4, #10 + WORD $0xaa0903e5 // mov x5, x9 +LBB0_388: + WORD $0xb4000171 // cbz x17, LBB0_392 $44(%rip) + WORD $0x388014a6 // ldrsb x6, [x5], #1 + WORD $0x9b0419ef // madd x15, x15, x4, x6 + WORD $0xd100c1ef // sub x15, x15, #48 + WORD $0xd1000631 // sub x17, x17, #1 + WORD $0xd1000400 // sub x0, x0, #1 + WORD $0xb5ffff40 // cbnz x0, LBB0_388 $-24(%rip) + WORD $0xaa0303f0 // mov x16, x3 + WORD $0x14000003 // b LBB0_392 $12(%rip) +LBB0_391: + WORD $0x52800010 // mov w16, #0 + WORD $0xd280000f // mov x15, #0 +LBB0_392: + WORD $0x6b1001b1 // subs w17, w13, w16 + WORD $0x540002ad // b.le LBB0_399 $84(%rip) + WORD $0x71000a3f // cmp w17, #2 + WORD $0x540001c3 // b.lo LBB0_397 $56(%rip) + WORD $0x121f7a20 // and w0, w17, #0xfffffffe + WORD $0x0b000210 // add w16, w16, w0 + WORD $0x52800023 // mov w3, #1 + WORD $0xaa0003e4 // mov x4, x0 +LBB0_395: + WORD $0x8b0f09ef // add x15, x15, x15, lsl #2 + WORD $0xd37ff9ef // lsl x15, x15, #1 + WORD $0x8b030863 // add x3, x3, x3, lsl #2 + WORD $0xd37ff863 // lsl x3, x3, #1 + WORD $0x71000884 // subs w4, w4, #2 + WORD $0x54ffff61 // b.ne LBB0_395 $-20(%rip) + WORD $0x9b0f7c6f // mul x15, x3, x15 + WORD $0x6b00023f // cmp w17, w0 + WORD $0x540000c0 // b.eq LBB0_399 $24(%rip) +LBB0_397: + WORD $0x4b1001b0 // sub w16, w13, w16 +LBB0_398: + WORD $0x8b0f09ef // add x15, x15, x15, lsl #2 + WORD $0xd37ff9ef // lsl x15, x15, #1 + WORD $0x71000610 // subs w16, w16, #1 + WORD $0x54ffffa1 // b.ne LBB0_398 $-12(%rip) +LBB0_399: + WORD $0x36f800ad // tbz w13, #31, LBB0_401 $20(%rip) + WORD $0x1400001a // b LBB0_407 $104(%rip) +LBB0_400: + WORD $0xd280000f // mov x15, #0 + WORD $0x5280000d // mov w13, #0 + WORD $0x5100054a // sub w10, w10, #1 +LBB0_401: + WORD $0x6b0d015f // cmp w10, w13 + WORD $0x540002ad // b.le LBB0_407 $84(%rip) + WORD $0x38ed4930 // ldrsb w16, [x9, w13, uxtw] + WORD $0x110005b1 // add w17, w13, #1 + WORD $0x7100d61f // cmp w16, #53 + WORD $0x7a4a0220 // ccmp w17, w10, #0, eq + WORD $0x54000100 // b.eq LBB0_404 $32(%rip) + WORD $0x7100d21f // cmp w16, #52 + WORD $0x1a9fd7e9 // cset w9, gt + WORD $0x8b2941e9 // add x9, x15, w9, uxtw + WORD $0xd2e0040a // mov x10, #9007199254740992 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x540002a1 // b.ne LBB0_411 $84(%rip) + WORD $0x1400000e // b LBB0_408 $56(%rip) +LBB0_404: + WORD $0x3400034c // cbz w12, LBB0_413 $104(%rip) + WORD $0x52800029 // mov w9, #1 + WORD $0x8b2941e9 // add x9, x15, w9, uxtw + WORD $0xd2e0040a // mov x10, #9007199254740992 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x540001c1 // b.ne LBB0_411 $56(%rip) + WORD $0x14000007 // b LBB0_408 $28(%rip) +LBB0_406: + WORD $0xd280000f // mov x15, #0 +LBB0_407: + WORD $0x52800009 // mov w9, #0 + WORD $0x8b2941e9 // add x9, x15, w9, uxtw + WORD $0xd2e0040a // mov x10, #9007199254740992 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x540000e1 // b.ne LBB0_411 $28(%rip) +LBB0_408: + WORD $0x710ff9df // cmp w14, #1022 + WORD $0x54ff878c // b.gt LBB0_139 $-3856(%rip) + WORD $0x110005ce // add w14, w14, #1 + WORD $0xd2e00209 // mov x9, #4503599627370496 + WORD $0x14000002 // b LBB0_411 $8(%rip) +LBB0_410: + WORD $0xd2800009 // mov x9, #0 +LBB0_411: + WORD $0x9374d12a // sbfx x10, x9, #52, #1 + WORD $0x110ffdcc // add w12, w14, #1023 + WORD $0x1200298c // and w12, w12, #0x7ff + WORD $0x8a0cd14a // and x10, x10, x12, lsl #52 + WORD $0x17fffc3a // b LBB0_142 $-3864(%rip) +LBB0_412: + WORD $0x52800010 // mov w16, #0 + WORD $0x17fffd19 // b LBB0_205 $-2972(%rip) +LBB0_413: + WORD $0x34fffdcd // cbz w13, LBB0_407 $-72(%rip) + WORD $0x510005aa // sub w10, w13, #1 + WORD $0x386a4929 // ldrb w9, [x9, w10, uxtw] + WORD $0x12000129 // and w9, w9, #0x1 + WORD $0x8b2941e9 // add x9, x15, w9, uxtw + WORD $0xd2e0040a // mov x10, #9007199254740992 + WORD $0xeb0a013f // cmp x9, x10 + WORD $0x54fffe41 // b.ne LBB0_411 $-56(%rip) + WORD $0x17ffffeb // b LBB0_408 $-84(%rip) + // .p2align 2, 0x00 +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + WORD $0x00000000 // .p2align 3, 0x00 +_P10_TAB: + WORD $0x00000000; WORD $0x3ff00000 // .quad 0x3ff0000000000000 + WORD $0x00000000; WORD $0x40240000 // .quad 0x4024000000000000 + WORD $0x00000000; WORD $0x40590000 // .quad 0x4059000000000000 + WORD $0x00000000; WORD $0x408f4000 // .quad 0x408f400000000000 + WORD $0x00000000; WORD $0x40c38800 // .quad 0x40c3880000000000 + WORD $0x00000000; WORD $0x40f86a00 // .quad 0x40f86a0000000000 + WORD $0x00000000; WORD $0x412e8480 // .quad 0x412e848000000000 + WORD $0x00000000; WORD $0x416312d0 // .quad 0x416312d000000000 + WORD $0x00000000; WORD $0x4197d784 // .quad 0x4197d78400000000 + WORD $0x00000000; WORD $0x41cdcd65 // .quad 0x41cdcd6500000000 + WORD $0x20000000; WORD $0x4202a05f // .quad 0x4202a05f20000000 + WORD $0xe8000000; WORD $0x42374876 // .quad 0x42374876e8000000 + WORD $0xa2000000; WORD $0x426d1a94 // .quad 0x426d1a94a2000000 + WORD $0xe5400000; WORD $0x42a2309c // .quad 0x42a2309ce5400000 + WORD $0x1e900000; WORD $0x42d6bcc4 // .quad 0x42d6bcc41e900000 + WORD $0x26340000; WORD $0x430c6bf5 // .quad 0x430c6bf526340000 + WORD $0x37e08000; WORD $0x4341c379 // .quad 0x4341c37937e08000 + WORD $0x85d8a000; WORD $0x43763457 // .quad 0x4376345785d8a000 + WORD $0x674ec800; WORD $0x43abc16d // .quad 0x43abc16d674ec800 + WORD $0x60913d00; WORD $0x43e158e4 // .quad 0x43e158e460913d00 + WORD $0x78b58c40; WORD $0x4415af1d // .quad 0x4415af1d78b58c40 + WORD $0xd6e2ef50; WORD $0x444b1ae4 // .quad 0x444b1ae4d6e2ef50 + WORD $0x064dd592; WORD $0x4480f0cf // .quad 0x4480f0cf064dd592 + // .p2align 3, 0x00 +_POW10_M128_TAB: + WORD $0xcd60e453; WORD $0x1732c869 // .quad 1671618768450675795 + WORD $0x081c0288; WORD $0xfa8fd5a0 // .quad -391859759250406776 + WORD $0x205c8eb4; WORD $0x0e7fbd42 // .quad 1044761730281672372 + WORD $0x05118195; WORD $0x9c99e584 // .quad -7162441377172586091 + WORD $0xa873b261; WORD $0x521fac92 // .quad 5917638181279478369 + WORD $0x0655e1fa; WORD $0xc3c05ee5 // .quad -4341365703038344710 + WORD $0x52909ef9; WORD $0xe6a797b7 // .quad -1826324310255427847 + WORD $0x47eb5a78; WORD $0xf4b0769e // .quad -815021110370542984 + WORD $0x939a635c; WORD $0x9028bed2 // .quad -8058981721550724260 + WORD $0xecf3188b; WORD $0x98ee4a22 // .quad -7426917221622671221 + WORD $0x3880fc33; WORD $0x7432ee87 // .quad 8373016921771146291 + WORD $0xa82fdeae; WORD $0xbf29dcab // .quad -4671960508600951122 + WORD $0x06a13b3f; WORD $0x113faa29 // .quad 1242899115359157055 + WORD $0x923bd65a; WORD $0xeef453d6 // .quad -1228264617323800998 + WORD $0xa424c507; WORD $0x4ac7ca59 // .quad 5388497965526861063 + WORD $0x1b6565f8; WORD $0x9558b466 // .quad -7685194413468457480 + WORD $0x0d2df649; WORD $0x5d79bcf0 // .quad 6735622456908576329 + WORD $0xa23ebf76; WORD $0xbaaee17f // .quad -4994806998408183946 + WORD $0x107973dc; WORD $0xf4d82c2c // .quad -803843965719055396 + WORD $0x8ace6f53; WORD $0xe95a99df // .quad -1631822729582842029 + WORD $0x8a4be869; WORD $0x79071b9b // .quad 8720969558280366185 + WORD $0xb6c10594; WORD $0x91d8a02b // .quad -7937418233630358124 + WORD $0x6cdee284; WORD $0x9748e282 // .quad -7545532125859093884 + WORD $0xa47146f9; WORD $0xb64ec836 // .quad -5310086773610559751 + WORD $0x08169b25; WORD $0xfd1b1b23 // .quad -208543120469091547 + WORD $0x4d8d98b7; WORD $0xe3e27a44 // .quad -2025922448585811785 + WORD $0xe50e20f7; WORD $0xfe30f0f5 // .quad -130339450293182217 + WORD $0xb0787f72; WORD $0x8e6d8c6a // .quad -8183730558007214222 + WORD $0x5e51a935; WORD $0xbdbd2d33 // .quad -4774610331293865675 + WORD $0x5c969f4f; WORD $0xb208ef85 // .quad -5617977179081629873 + WORD $0x35e61382; WORD $0xad2c7880 // .quad -5968262914117332094 + WORD $0xb3bc4723; WORD $0xde8b2b66 // .quad -2410785455424649437 + WORD $0x21afcc31; WORD $0x4c3bcb50 // .quad 5493207715531443249 + WORD $0x3055ac76; WORD $0x8b16fb20 // .quad -8424269937281487754 + WORD $0x2a1bbf3d; WORD $0xdf4abe24 // .quad -2356862392440471747 + WORD $0x3c6b1793; WORD $0xaddcb9e8 // .quad -5918651403174471789 + WORD $0x34a2af0d; WORD $0xd71d6dad // .quad -2946077990550589683 + WORD $0x4b85dd78; WORD $0xd953e862 // .quad -2786628235540701832 + WORD $0x40e5ad68; WORD $0x8672648c // .quad -8758827771735200408 + WORD $0x6f33aa6b; WORD $0x87d4713d // .quad -8659171674854020501 + WORD $0x511f18c2; WORD $0x680efdaf // .quad 7498209359040551106 + WORD $0xcb009506; WORD $0xa9c98d8c // .quad -6212278575140137722 + WORD $0x2566def2; WORD $0x0212bd1b // .quad 149389661945913074 + WORD $0xfdc0ba48; WORD $0xd43bf0ef // .quad -3153662200497784248 + WORD $0xf7604b57; WORD $0x014bb630 // .quad 93368538716195671 + WORD $0xfe98746d; WORD $0x84a57695 // .quad -8888567902952197011 + WORD $0x35385e2d; WORD $0x419ea3bd // .quad 4728396691822632493 + WORD $0x7e3e9188; WORD $0xa5ced43b // .quad -6499023860262858360 + WORD $0x828675b9; WORD $0x52064cac // .quad 5910495864778290617 + WORD $0x5dce35ea; WORD $0xcf42894a // .quad -3512093806901185046 + WORD $0xd1940993; WORD $0x7343efeb // .quad 8305745933913819539 + WORD $0x7aa0e1b2; WORD $0x818995ce // .quad -9112587656954322510 + WORD $0xc5f90bf8; WORD $0x1014ebe6 // .quad 1158810380537498616 + WORD $0x19491a1f; WORD $0xa1ebfb42 // .quad -6779048552765515233 + WORD $0x77774ef6; WORD $0xd41a26e0 // .quad -3163173042755514634 + WORD $0x9f9b60a6; WORD $0xca66fa12 // .quad -3862124672529506138 + WORD $0x955522b4; WORD $0x8920b098 // .quad -8565652321871781196 + WORD $0x478238d0; WORD $0xfd00b897 // .quad -215969822234494768 + WORD $0x5d5535b0; WORD $0x55b46e5f // .quad 6175682344898606512 + WORD $0x8cb16382; WORD $0x9e20735e // .quad -7052510166537641086 + WORD $0x34aa831d; WORD $0xeb2189f7 // .quad -1503769105731517667 + WORD $0x2fddbc62; WORD $0xc5a89036 // .quad -4203951689744663454 + WORD $0x01d523e4; WORD $0xa5e9ec75 // .quad -6491397400591784988 + WORD $0xbbd52b7b; WORD $0xf712b443 // .quad -643253593753441413 + WORD $0x2125366e; WORD $0x47b233c9 // .quad 5166248661484910190 + WORD $0x55653b2d; WORD $0x9a6bb0aa // .quad -7319562523736982739 + WORD $0x696e840a; WORD $0x999ec0bb // .quad -7377247228426025974 + WORD $0xeabe89f8; WORD $0xc1069cd4 // .quad -4537767136243840520 + WORD $0x43ca250d; WORD $0xc00670ea // .quad -4609873017105144563 + WORD $0x256e2c76; WORD $0xf148440a // .quad -1060522901877412746 + WORD $0x6a5e5728; WORD $0x38040692 // .quad 4036358391950366504 + WORD $0x5764dbca; WORD $0x96cd2a86 // .quad -7580355841314464822 + WORD $0x04f5ecf2; WORD $0xc6050837 // .quad -4177924046916817678 + WORD $0xed3e12bc; WORD $0xbc807527 // .quad -4863758783215693124 + WORD $0xc633682e; WORD $0xf7864a44 // .quad -610719040218634194 + WORD $0xe88d976b; WORD $0xeba09271 // .quad -1468012460592228501 + WORD $0xfbe0211d; WORD $0x7ab3ee6a // .quad 8841672636718129437 + WORD $0x31587ea3; WORD $0x93445b87 // .quad -7835036815511224669 + WORD $0xbad82964; WORD $0x5960ea05 // .quad 6440404777470273892 + WORD $0xfdae9e4c; WORD $0xb8157268 // .quad -5182110000961642932 + WORD $0x298e33bd; WORD $0x6fb92487 // .quad 8050505971837842365 + WORD $0x3d1a45df; WORD $0xe61acf03 // .quad -1865951482774665761 + WORD $0x79f8e056; WORD $0xa5d3b6d4 // .quad -6497648813669818282 + WORD $0x06306bab; WORD $0x8fd0c162 // .quad -8083748704375247957 + WORD $0x9877186c; WORD $0x8f48a489 // .quad -8122061017087272852 + WORD $0x87bc8696; WORD $0xb3c4f1ba // .quad -5492999862041672042 + WORD $0xfe94de87; WORD $0x331acdab // .quad 3682481783923072647 + WORD $0x29aba83c; WORD $0xe0b62e29 // .quad -2254563809124702148 + WORD $0x7f1d0b14; WORD $0x9ff0c08b // .quad -6921820921902855404 + WORD $0xba0b4925; WORD $0x8c71dcd9 // .quad -8326631408344020699 + WORD $0x5ee44dd9; WORD $0x07ecf0ae // .quad 571095884476206553 + WORD $0x288e1b6f; WORD $0xaf8e5410 // .quad -5796603242002637969 + WORD $0xf69d6150; WORD $0xc9e82cd9 // .quad -3897816162832129712 + WORD $0x32b1a24a; WORD $0xdb71e914 // .quad -2634068034075909558 + WORD $0x3a225cd2; WORD $0xbe311c08 // .quad -4741978110983775022 + WORD $0x9faf056e; WORD $0x892731ac // .quad -8563821548938525330 + WORD $0x48aaf406; WORD $0x6dbd630a // .quad 7907585416552444934 + WORD $0xc79ac6ca; WORD $0xab70fe17 // .quad -6093090917745768758 + WORD $0xdad5b108; WORD $0x092cbbcc // .quad 661109733835780360 + WORD $0xb981787d; WORD $0xd64d3d9d // .quad -3004677628754823043 + WORD $0x08c58ea5; WORD $0x25bbf560 // .quad 2719036592861056677 + WORD $0x93f0eb4e; WORD $0x85f04682 // .quad -8795452545612846258 + WORD $0x0af6f24e; WORD $0xaf2af2b8 // .quad -5824576295778454962 + WORD $0x38ed2621; WORD $0xa76c5823 // .quad -6382629663588669919 + WORD $0x0db4aee1; WORD $0x1af5af66 // .quad 1942651667131707105 + WORD $0x07286faa; WORD $0xd1476e2c // .quad -3366601061058449494 + WORD $0xc890ed4d; WORD $0x50d98d9f // .quad 5825843310384704845 + WORD $0x847945ca; WORD $0x82cca4db // .quad -9021654690802612790 + WORD $0xbab528a0; WORD $0xe50ff107 // .quad -1941067898873894752 + WORD $0x6597973c; WORD $0xa37fce12 // .quad -6665382345075878084 + WORD $0xa96272c8; WORD $0x1e53ed49 // .quad 2185351144835019464 + WORD $0xfefd7d0c; WORD $0xcc5fc196 // .quad -3720041912917459700 + WORD $0x13bb0f7a; WORD $0x25e8e89c // .quad 2731688931043774330 + WORD $0xbebcdc4f; WORD $0xff77b1fc // .quad -38366372719436721 + WORD $0x8c54e9ac; WORD $0x77b19161 // .quad 8624834609543440812 + WORD $0xf73609b1; WORD $0x9faacf3d // .quad -6941508010590729807 + WORD $0xef6a2417; WORD $0xd59df5b9 // .quad -3054014793352862697 + WORD $0x75038c1d; WORD $0xc795830d // .quad -4065198994811024355 + WORD $0x6b44ad1d; WORD $0x4b057328 // .quad 5405853545163697437 + WORD $0xd2446f25; WORD $0xf97ae3d0 // .quad -469812725086392539 + WORD $0x430aec32; WORD $0x4ee367f9 // .quad 5684501474941004850 + WORD $0x836ac577; WORD $0x9becce62 // .quad -7211161980820077193 + WORD $0x93cda73f; WORD $0x229c41f7 // .quad 2493940825248868159 + WORD $0x244576d5; WORD $0xc2e801fb // .quad -4402266457597708587 + WORD $0x78c1110f; WORD $0x6b435275 // .quad 7729112049988473103 + WORD $0xed56d48a; WORD $0xf3a20279 // .quad -891147053569747830 + WORD $0x6b78aaa9; WORD $0x830a1389 // .quad -9004363024039368023 + WORD $0x345644d6; WORD $0x9845418c // .quad -7474495936122174250 + WORD $0xc656d553; WORD $0x23cc986b // .quad 2579604275232953683 + WORD $0x416bd60c; WORD $0xbe5691ef // .quad -4731433901725329908 + WORD $0xb7ec8aa8; WORD $0x2cbfbe86 // .quad 3224505344041192104 + WORD $0x11c6cb8f; WORD $0xedec366b // .quad -1302606358729274481 + WORD $0x32f3d6a9; WORD $0x7bf7d714 // .quad 8932844867666826921 + WORD $0xeb1c3f39; WORD $0x94b3a202 // .quad -7731658001846878407 + WORD $0x3fb0cc53; WORD $0xdaf5ccd9 // .quad -2669001970698630061 + WORD $0xa5e34f07; WORD $0xb9e08a83 // .quad -5052886483881210105 + WORD $0x8f9cff68; WORD $0xd1b3400f // .quad -3336252463373287576 + WORD $0x8f5c22c9; WORD $0xe858ad24 // .quad -1704422086424124727 + WORD $0xb9c21fa1; WORD $0x23100809 // .quad 2526528228819083169 + WORD $0xd99995be; WORD $0x91376c36 // .quad -7982792831656159810 + WORD $0x2832a78a; WORD $0xabd40a0c // .quad -6065211750830921846 + WORD $0x8ffffb2d; WORD $0xb5854744 // .quad -5366805021142811859 + WORD $0x323f516c; WORD $0x16c90c8f // .quad 1641857348316123500 + WORD $0xb3fff9f9; WORD $0xe2e69915 // .quad -2096820258001126919 + WORD $0x7f6792e3; WORD $0xae3da7d9 // .quad -5891368184943504669 + WORD $0x907ffc3b; WORD $0x8dd01fad // .quad -8228041688891786181 + WORD $0xdf41779c; WORD $0x99cd11cf // .quad -7364210231179380836 + WORD $0xf49ffb4a; WORD $0xb1442798 // .quad -5673366092687344822 + WORD $0xd711d583; WORD $0x40405643 // .quad 4629795266307937667 + WORD $0x31c7fa1d; WORD $0xdd95317f // .quad -2480021597431793123 + WORD $0x666b2572; WORD $0x482835ea // .quad 5199465050656154994 + WORD $0x7f1cfc52; WORD $0x8a7d3eef // .quad -8467542526035952558 + WORD $0x0005eecf; WORD $0xda324365 // .quad -2724040723534582065 + WORD $0x5ee43b66; WORD $0xad1c8eab // .quad -5972742139117552794 + WORD $0x40076a82; WORD $0x90bed43e // .quad -8016736922845615486 + WORD $0x369d4a40; WORD $0xd863b256 // .quad -2854241655469553088 + WORD $0xe804a291; WORD $0x5a7744a6 // .quad 6518754469289960081 + WORD $0xe2224e68; WORD $0x873e4f75 // .quad -8701430062309552536 + WORD $0xa205cb36; WORD $0x711515d0 // .quad 8148443086612450102 + WORD $0x5aaae202; WORD $0xa90de353 // .quad -6265101559459552766 + WORD $0xca873e03; WORD $0x0d5a5b44 // .quad 962181821410786819 + WORD $0x31559a83; WORD $0xd3515c28 // .quad -3219690930897053053 + WORD $0xfe9486c2; WORD $0xe858790a // .quad -1704479370831952190 + WORD $0x1ed58091; WORD $0x8412d999 // .quad -8929835859451740015 + WORD $0xbe39a872; WORD $0x626e974d // .quad 7092772823314835570 + WORD $0x668ae0b6; WORD $0xa5178fff // .quad -6550608805887287114 + WORD $0x2dc8128f; WORD $0xfb0a3d21 // .quad -357406007711231345 + WORD $0x402d98e3; WORD $0xce5d73ff // .quad -3576574988931720989 + WORD $0xbc9d0b99; WORD $0x7ce66634 // .quad 8999993282035256217 + WORD $0x881c7f8e; WORD $0x80fa687f // .quad -9152888395723407474 + WORD $0xebc44e80; WORD $0x1c1fffc1 // .quad 2026619565689294464 + WORD $0x6a239f72; WORD $0xa139029f // .quad -6829424476226871438 + WORD $0x66b56220; WORD $0xa327ffb2 // .quad -6690097579743157728 + WORD $0x44ac874e; WORD $0xc9874347 // .quad -3925094576856201394 + WORD $0x0062baa8; WORD $0x4bf1ff9f // .quad 5472436080603216552 + WORD $0x15d7a922; WORD $0xfbe91419 // .quad -294682202642863838 + WORD $0x603db4a9; WORD $0x6f773fc3 // .quad 8031958568804398249 + WORD $0xada6c9b5; WORD $0x9d71ac8f // .quad -7101705404292871755 + WORD $0x384d21d3; WORD $0xcb550fb4 // .quad -3795109844276665901 + WORD $0x99107c22; WORD $0xc4ce17b3 // .quad -4265445736938701790 + WORD $0x46606a48; WORD $0x7e2a53a1 // .quad 9091170749936331336 + WORD $0x7f549b2b; WORD $0xf6019da0 // .quad -720121152745989333 + WORD $0xcbfc426d; WORD $0x2eda7444 // .quad 3376138709496513133 + WORD $0x4f94e0fb; WORD $0x99c10284 // .quad -7367604748107325189 + WORD $0xfefb5308; WORD $0xfa911155 // .quad -391512631556746488 + WORD $0x637a1939; WORD $0xc0314325 // .quad -4597819916706768583 + WORD $0x7eba27ca; WORD $0x793555ab // .quad 8733981247408842698 + WORD $0xbc589f88; WORD $0xf03d93ee // .quad -1135588877456072824 + WORD $0x2f3458de; WORD $0x4bc1558b // .quad 5458738279630526686 + WORD $0x35b763b5; WORD $0x96267c75 // .quad -7627272076051127371 + WORD $0xfb016f16; WORD $0x9eb1aaed // .quad -7011635205744005354 + WORD $0x83253ca2; WORD $0xbbb01b92 // .quad -4922404076636521310 + WORD $0x79c1cadc; WORD $0x465e15a9 // .quad 5070514048102157020 + WORD $0x23ee8bcb; WORD $0xea9c2277 // .quad -1541319077368263733 + WORD $0xec191ec9; WORD $0x0bfacd89 // .quad 863228270850154185 + WORD $0x7675175f; WORD $0x92a1958a // .quad -7880853450996246689 + WORD $0x671f667b; WORD $0xcef980ec // .quad -3532650679864695173 + WORD $0x14125d36; WORD $0xb749faed // .quad -5239380795317920458 + WORD $0x80e7401a; WORD $0x82b7e127 // .quad -9027499368258256870 + WORD $0x5916f484; WORD $0xe51c79a8 // .quad -1937539975720012668 + WORD $0xb0908810; WORD $0xd1b2ecb8 // .quad -3336344095947716592 + WORD $0x37ae58d2; WORD $0x8f31cc09 // .quad -8128491512466089774 + WORD $0xdcb4aa15; WORD $0x861fa7e6 // .quad -8782116138362033643 + WORD $0x8599ef07; WORD $0xb2fe3f0b // .quad -5548928372155224313 + WORD $0x93e1d49a; WORD $0x67a791e0 // .quad 7469098900757009562 + WORD $0x67006ac9; WORD $0xdfbdcece // .quad -2324474446766642487 + WORD $0x5c6d24e0; WORD $0xe0c8bb2c // .quad -2249342214667950880 + WORD $0x006042bd; WORD $0x8bd6a141 // .quad -8370325556870233411 + WORD $0x73886e18; WORD $0x58fae9f7 // .quad 6411694268519837208 + WORD $0x4078536d; WORD $0xaecc4991 // .quad -5851220927660403859 + WORD $0x506a899e; WORD $0xaf39a475 // .quad -5820440219632367202 + WORD $0x90966848; WORD $0xda7f5bf5 // .quad -2702340141148116920 + WORD $0x52429603; WORD $0x6d8406c9 // .quad 7891439908798240259 + WORD $0x7a5e012d; WORD $0x888f9979 // .quad -8606491615858654931 + WORD $0xa6d33b83; WORD $0xc8e5087b // .quad -3970758169284363389 + WORD $0xd8f58178; WORD $0xaab37fd7 // .quad -6146428501395930760 + WORD $0x90880a64; WORD $0xfb1e4a9a // .quad -351761693178066332 + WORD $0xcf32e1d6; WORD $0xd5605fcd // .quad -3071349608317525546 + WORD $0x9a55067f; WORD $0x5cf2eea0 // .quad 6697677969404790399 + WORD $0xa17fcd26; WORD $0x855c3be0 // .quad -8837122532839535322 + WORD $0xc0ea481e; WORD $0xf42faa48 // .quad -851274575098787810 + WORD $0xc9dfc06f; WORD $0xa6b34ad8 // .quad -6434717147622031249 + WORD $0xf124da26; WORD $0xf13b94da // .quad -1064093218873484762 + WORD $0xfc57b08b; WORD $0xd0601d8e // .quad -3431710416100151157 + WORD $0xd6b70858; WORD $0x76c53d08 // .quad 8558313775058847832 + WORD $0x5db6ce57; WORD $0x823c1279 // .quad -9062348037703676329 + WORD $0x0c64ca6e; WORD $0x54768c4b // .quad 6086206200396171886 + WORD $0xb52481ed; WORD $0xa2cb1717 // .quad -6716249028702207507 + WORD $0xcf7dfd09; WORD $0xa9942f5d // .quad -6227300304786948855 + WORD $0xa26da268; WORD $0xcb7ddcdd // .quad -3783625267450371480 + WORD $0x435d7c4c; WORD $0xd3f93b35 // .quad -3172439362556298164 + WORD $0x0b090b02; WORD $0xfe5d5415 // .quad -117845565885576446 + WORD $0x4a1a6daf; WORD $0xc47bc501 // .quad -4288617610811380305 + WORD $0x26e5a6e1; WORD $0x9efa548d // .quad -6991182506319567135 + WORD $0x9ca1091b; WORD $0x359ab641 // .quad 3862600023340550427 + WORD $0x709f109a; WORD $0xc6b8e9b0 // .quad -4127292114472071014 + WORD $0x03c94b62; WORD $0xc30163d2 // .quad -4395122007679087774 + WORD $0x8cc6d4c0; WORD $0xf867241c // .quad -547429124662700864 + WORD $0x425dcf1d; WORD $0x79e0de63 // .quad 8782263791269039901 + WORD $0xd7fc44f8; WORD $0x9b407691 // .quad -7259672230555269896 + WORD $0x12f542e4; WORD $0x985915fc // .quad -7468914334623251740 + WORD $0x4dfb5636; WORD $0xc2109436 // .quad -4462904269766699466 + WORD $0x17b2939d; WORD $0x3e6f5b7b // .quad 4498915137003099037 + WORD $0xe17a2bc4; WORD $0xf294b943 // .quad -966944318780986428 + WORD $0xeecf9c42; WORD $0xa705992c // .quad -6411550076227838910 + WORD $0x6cec5b5a; WORD $0x979cf3ca // .quad -7521869226879198374 + WORD $0x2a838353; WORD $0x50c6ff78 // .quad 5820620459997365075 + WORD $0x08277231; WORD $0xbd8430bd // .quad -4790650515171610063 + WORD $0x35246428; WORD $0xa4f8bf56 // .quad -6559282480285457368 + WORD $0x4a314ebd; WORD $0xece53cec // .quad -1376627125537124675 + WORD $0xe136be99; WORD $0x871b7795 // .quad -8711237568605798759 + WORD $0xae5ed136; WORD $0x940f4613 // .quad -7777920981101784778 + WORD $0x59846e3f; WORD $0x28e2557b // .quad 2946011094524915263 + WORD $0x99f68584; WORD $0xb9131798 // .quad -5110715207949843068 + WORD $0x2fe589cf; WORD $0x331aeada // .quad 3682513868156144079 + WORD $0xc07426e5; WORD $0xe757dd7e // .quad -1776707991509915931 + WORD $0x5def7621; WORD $0x3ff0d2c8 // .quad 4607414176811284001 + WORD $0x3848984f; WORD $0x9096ea6f // .quad -8027971522334779313 + WORD $0x756b53a9; WORD $0x0fed077a // .quad 1147581702586717097 + WORD $0x065abe63; WORD $0xb4bca50b // .quad -5423278384491086237 + WORD $0x12c62894; WORD $0xd3e84959 // .quad -3177208890193991532 + WORD $0xc7f16dfb; WORD $0xe1ebce4d // .quad -2167411962186469893 + WORD $0xabbbd95c; WORD $0x64712dd7 // .quad 7237616480483531100 + WORD $0x9cf6e4bd; WORD $0x8d3360f0 // .quad -8272161504007625539 + WORD $0x96aacfb3; WORD $0xbd8d794d // .quad -4788037454677749837 + WORD $0xc4349dec; WORD $0xb080392c // .quad -5728515861582144020 + WORD $0xfc5583a0; WORD $0xecf0d7a0 // .quad -1373360799919799392 + WORD $0xf541c567; WORD $0xdca04777 // .quad -2548958808550292121 + WORD $0x9db57244; WORD $0xf41686c4 // .quad -858350499949874620 + WORD $0xf9491b60; WORD $0x89e42caa // .quad -8510628282985014432 + WORD $0xc522ced5; WORD $0x311c2875 // .quad 3538747893490044629 + WORD $0xb79b6239; WORD $0xac5d37d5 // .quad -6026599335303880135 + WORD $0x366b828b; WORD $0x7d633293 // .quad 9035120885289943691 + WORD $0x25823ac7; WORD $0xd77485cb // .quad -2921563150702462265 + WORD $0x02033197; WORD $0xae5dff9c // .quad -5882264492762254953 + WORD $0xf77164bc; WORD $0x86a8d39e // .quad -8743505996830120772 + WORD $0x0283fdfc; WORD $0xd9f57f83 // .quad -2741144597525430788 + WORD $0xb54dbdeb; WORD $0xa8530886 // .quad -6317696477610263061 + WORD $0xc324fd7b; WORD $0xd072df63 // .quad -3426430746906788485 + WORD $0x62a12d66; WORD $0xd267caa8 // .quad -3285434578585440922 + WORD $0x59f71e6d; WORD $0x4247cb9e // .quad 4776009810824339053 + WORD $0x3da4bc60; WORD $0x8380dea9 // .quad -8970925639256982432 + WORD $0xf074e608; WORD $0x52d9be85 // .quad 5970012263530423816 + WORD $0x8d0deb78; WORD $0xa4611653 // .quad -6601971030643840136 + WORD $0x6c921f8b; WORD $0x67902e27 // .quad 7462515329413029771 + WORD $0x70516656; WORD $0xcd795be8 // .quad -3640777769877412266 + WORD $0xa3db53b6; WORD $0x00ba1cd8 // .quad 52386062455755702 + WORD $0x4632dff6; WORD $0x806bd971 // .quad -9193015133814464522 + WORD $0xccd228a4; WORD $0x80e8a40e // .quad -9157889458785081180 + WORD $0x97bf97f3; WORD $0xa086cfcd // .quad -6879582898840692749 + WORD $0x8006b2cd; WORD $0x6122cd12 // .quad 6999382250228200141 + WORD $0xfdaf7df0; WORD $0xc8a883c0 // .quad -3987792605123478032 + WORD $0x20085f81; WORD $0x796b8057 // .quad 8749227812785250177 + WORD $0x3d1b5d6c; WORD $0xfad2a4b1 // .quad -373054737976959636 + WORD $0x74053bb0; WORD $0xcbe33036 // .quad -3755104653863994448 + WORD $0xc6311a63; WORD $0x9cc3a6ee // .quad -7150688238876681629 + WORD $0x11068a9c; WORD $0xbedbfc44 // .quad -4693880817329993060 + WORD $0x77bd60fc; WORD $0xc3f490aa // .quad -4326674280168464132 + WORD $0x15482d44; WORD $0xee92fb55 // .quad -1255665003235103420 + WORD $0x15acb93b; WORD $0xf4f1b4d5 // .quad -796656831783192261 + WORD $0x2d4d1c4a; WORD $0x751bdd15 // .quad 8438581409832836170 + WORD $0x2d8bf3c5; WORD $0x99171105 // .quad -7415439547505577019 + WORD $0x78a0635d; WORD $0xd262d45a // .quad -3286831292991118499 + WORD $0x78eef0b6; WORD $0xbf5cd546 // .quad -4657613415954583370 + WORD $0x16c87c34; WORD $0x86fb8971 // .quad -8720225134666286028 + WORD $0x172aace4; WORD $0xef340a98 // .quad -1210330751515841308 + WORD $0xae3d4da0; WORD $0xd45d35e6 // .quad -3144297699952734816 + WORD $0x0e7aac0e; WORD $0x9580869f // .quad -7673985747338482674 + WORD $0x59cca109; WORD $0x89748360 // .quad -8542058143368306423 + WORD $0xd2195712; WORD $0xbae0a846 // .quad -4980796165745715438 + WORD $0x703fc94b; WORD $0x2bd1a438 // .quad 3157485376071780683 + WORD $0x869facd7; WORD $0xe998d258 // .quad -1614309188754756393 + WORD $0x4627ddcf; WORD $0x7b6306a3 // .quad 8890957387685944783 + WORD $0x5423cc06; WORD $0x91ff8377 // .quad -7926472270612804602 + WORD $0x17b1d542; WORD $0x1a3bc84c // .quad 1890324697752655170 + WORD $0x292cbf08; WORD $0xb67f6455 // .quad -5296404319838617848 + WORD $0x1d9e4a93; WORD $0x20caba5f // .quad 2362905872190818963 + WORD $0x7377eeca; WORD $0xe41f3d6a // .quad -2008819381370884406 + WORD $0x7282ee9c; WORD $0x547eb47b // .quad 6088502188546649756 + WORD $0x882af53e; WORD $0x8e938662 // .quad -8173041140997884610 + WORD $0x4f23aa43; WORD $0xe99e619a // .quad -1612744301171463613 + WORD $0x2a35b28d; WORD $0xb23867fb // .quad -5604615407819967859 + WORD $0xe2ec94d4; WORD $0x6405fa00 // .quad 7207441660390446292 + WORD $0xf4c31f31; WORD $0xdec681f9 // .quad -2394083241347571919 + WORD $0x8dd3dd04; WORD $0xde83bc40 // .quad -2412877989897052924 + WORD $0x38f9f37e; WORD $0x8b3c113c // .quad -8413831053483314306 + WORD $0xb148d445; WORD $0x9624ab50 // .quad -7627783505798704059 + WORD $0x4738705e; WORD $0xae0b158b // .quad -5905602798426754978 + WORD $0xdd9b0957; WORD $0x3badd624 // .quad 4300328673033783639 + WORD $0x19068c76; WORD $0xd98ddaee // .quad -2770317479606055818 + WORD $0x0a80e5d6; WORD $0xe54ca5d7 // .quad -1923980597781273130 + WORD $0xcfa417c9; WORD $0x87f8a8d4 // .quad -8648977452394866743 + WORD $0xcd211f4c; WORD $0x5e9fcf4c // .quad 6818396289628184396 + WORD $0x038d1dbc; WORD $0xa9f6d30a // .quad -6199535797066195524 + WORD $0x0069671f; WORD $0x7647c320 // .quad 8522995362035230495 + WORD $0x8470652b; WORD $0xd47487cc // .quad -3137733727905356501 + WORD $0x0041e073; WORD $0x29ecd9f4 // .quad 3021029092058325107 + WORD $0xd2c63f3b; WORD $0x84c8d4df // .quad -8878612607581929669 + WORD $0x00525890; WORD $0xf4681071 // .quad -835399653354481520 + WORD $0xc777cf09; WORD $0xa5fb0a17 // .quad -6486579741050024183 + WORD $0x4066eeb4; WORD $0x7182148d // .quad 8179122470161673908 + WORD $0xb955c2cc; WORD $0xcf79cc9d // .quad -3496538657885142324 + WORD $0x48405530; WORD $0xc6f14cd8 // .quad -4111420493003729616 + WORD $0x93d599bf; WORD $0x81ac1fe2 // .quad -9102865688819295809 + WORD $0x5a506a7c; WORD $0xb8ada00e // .quad -5139275616254662020 + WORD $0x38cb002f; WORD $0xa21727db // .quad -6766896092596731857 + WORD $0xf0e4851c; WORD $0xa6d90811 // .quad -6424094520318327524 + WORD $0x06fdc03b; WORD $0xca9cf1d2 // .quad -3846934097318526917 + WORD $0x6d1da663; WORD $0x908f4a16 // .quad -8030118150397909405 + WORD $0x88bd304a; WORD $0xfd442e46 // .quad -196981603220770742 + WORD $0x043287fe; WORD $0x9a598e4e // .quad -7324666853212387330 + WORD $0x15763e2e; WORD $0x9e4a9cec // .quad -7040642529654063570 + WORD $0x853f29fd; WORD $0x40eff1e1 // .quad 4679224488766679549 + WORD $0x1ad3cdba; WORD $0xc5dd4427 // .quad -4189117143640191558 + WORD $0xe68ef47c; WORD $0xd12bee59 // .quad -3374341425896426372 + WORD $0xe188c128; WORD $0xf7549530 // .quad -624710411122851544 + WORD $0x301958ce; WORD $0x82bb74f8 // .quad -9026492418826348338 + WORD $0x8cf578b9; WORD $0x9a94dd3e // .quad -7307973034592864071 + WORD $0x3c1faf01; WORD $0xe36a5236 // .quad -2059743486678159615 + WORD $0x3032d6e7; WORD $0xc13a148e // .quad -4523280274813692185 + WORD $0xcb279ac1; WORD $0xdc44e6c3 // .quad -2574679358347699519 + WORD $0xbc3f8ca1; WORD $0xf18899b1 // .quad -1042414325089727327 + WORD $0x5ef8c0b9; WORD $0x29ab103a // .quad 3002511419460075705 + WORD $0x15a7b7e5; WORD $0x96f5600f // .quad -7569037980822161435 + WORD $0xf6b6f0e7; WORD $0x7415d448 // .quad 8364825292752482535 + WORD $0xdb11a5de; WORD $0xbcb2b812 // .quad -4849611457600313890 + WORD $0x3464ad21; WORD $0x111b495b // .quad 1232659579085827361 + WORD $0x91d60f56; WORD $0xebdf6617 // .quad -1450328303573004458 + WORD $0x00beec34; WORD $0xcab10dd9 // .quad -3841273781498745804 + WORD $0xbb25c995; WORD $0x936b9fce // .quad -7823984217374209643 + WORD $0x40eea742; WORD $0x3d5d514f // .quad 4421779809981343554 + WORD $0x69ef3bfb; WORD $0xb84687c2 // .quad -5168294253290374149 + WORD $0x112a5112; WORD $0x0cb4a5a3 // .quad 915538744049291538 + WORD $0x046b0afa; WORD $0xe65829b3 // .quad -1848681798185579782 + WORD $0xeaba72ab; WORD $0x47f0e785 // .quad 5183897733458195115 + WORD $0xe2c2e6dc; WORD $0x8ff71a0f // .quad -8072955151507069220 + WORD $0x65690f56; WORD $0x59ed2167 // .quad 6479872166822743894 + WORD $0xdb73a093; WORD $0xb3f4e093 // .quad -5479507920956448621 + WORD $0x3ec3532c; WORD $0x306869c1 // .quad 3488154190101041964 + WORD $0xd25088b8; WORD $0xe0f218b8 // .quad -2237698882768172872 + WORD $0xc73a13fb; WORD $0x1e414218 // .quad 2180096368813151227 + WORD $0x83725573; WORD $0x8c974f73 // .quad -8316090829371189901 + WORD $0xf90898fa; WORD $0xe5d1929e // .quad -1886565557410948870 + WORD $0x644eeacf; WORD $0xafbd2350 // .quad -5783427518286599473 + WORD $0xb74abf39; WORD $0xdf45f746 // .quad -2358206946763686087 + WORD $0x7d62a583; WORD $0xdbac6c24 // .quad -2617598379430861437 + WORD $0x328eb783; WORD $0x6b8bba8c // .quad 7749492695127472003 + WORD $0xce5da772; WORD $0x894bc396 // .quad -8553528014785370254 + WORD $0x3f326564; WORD $0x066ea92f // .quad 463493832054564196 + WORD $0x81f5114f; WORD $0xab9eb47c // .quad -6080224000054324913 + WORD $0x0efefebd; WORD $0xc80a537b // .quad -4032318728359182659 + WORD $0xa27255a2; WORD $0xd686619b // .quad -2988593981640518238 + WORD $0xe95f5f36; WORD $0xbd06742c // .quad -4826042214438183114 + WORD $0x45877585; WORD $0x8613fd01 // .quad -8785400266166405755 + WORD $0x23b73704; WORD $0x2c481138 // .quad 3190819268807046916 + WORD $0x96e952e7; WORD $0xa798fc41 // .quad -6370064314280619289 + WORD $0x2ca504c5; WORD $0xf75a1586 // .quad -623161932418579259 + WORD $0xfca3a7a0; WORD $0xd17f3b51 // .quad -3350894374423386208 + WORD $0xdbe722fb; WORD $0x9a984d73 // .quad -7307005235402693893 + WORD $0x3de648c4; WORD $0x82ef8513 // .quad -9011838011655698236 + WORD $0xd2e0ebba; WORD $0xc13e60d0 // .quad -4522070525825979462 + WORD $0x0d5fdaf5; WORD $0xa3ab6658 // .quad -6653111496142234891 + WORD $0x079926a8; WORD $0x318df905 // .quad 3570783879572301480 + WORD $0x10b7d1b3; WORD $0xcc963fee // .quad -3704703351750405709 + WORD $0x497f7052; WORD $0xfdf17746 // .quad -148206168962011054 + WORD $0x94e5c61f; WORD $0xffbbcfe9 // .quad -19193171260619233 + WORD $0xedefa633; WORD $0xfeb6ea8b // .quad -92628855601256909 + WORD $0xfd0f9bd3; WORD $0x9fd561f1 // .quad -6929524759678968877 + WORD $0xe96b8fc0; WORD $0xfe64a52e // .quad -115786069501571136 + WORD $0x7c5382c8; WORD $0xc7caba6e // .quad -4050219931171323192 + WORD $0xa3c673b0; WORD $0x3dfdce7a // .quad 4466953431550423984 + WORD $0x1b68637b; WORD $0xf9bd690a // .quad -451088895536766085 + WORD $0xa65c084e; WORD $0x06bea10c // .quad 486002885505321038 + WORD $0x51213e2d; WORD $0x9c1661a6 // .quad -7199459587351560659 + WORD $0xcff30a62; WORD $0x486e494f // .quad 5219189625309039202 + WORD $0xe5698db8; WORD $0xc31bfa0f // .quad -4387638465762062920 + WORD $0xc3efccfa; WORD $0x5a89dba3 // .quad 6523987031636299002 + WORD $0xdec3f126; WORD $0xf3e2f893 // .quad -872862063775190746 + WORD $0x5a75e01c; WORD $0xf8962946 // .quad -534194123654701028 + WORD $0x6b3a76b7; WORD $0x986ddb5c // .quad -7463067817500576073 + WORD $0xf1135823; WORD $0xf6bbb397 // .quad -667742654568376285 + WORD $0x86091465; WORD $0xbe895233 // .quad -4717148753448332187 + WORD $0xed582e2c; WORD $0x746aa07d // .quad 8388693718644305452 + WORD $0x678b597f; WORD $0xee2ba6c0 // .quad -1284749923383027329 + WORD $0xb4571cdc; WORD $0xa8c2a44e // .quad -6286281471915778852 + WORD $0x40b717ef; WORD $0x94db4838 // .quad -7720497729755473937 + WORD $0x616ce413; WORD $0x92f34d62 // .quad -7857851839894723565 + WORD $0x50e4ddeb; WORD $0xba121a46 // .quad -5038936143766954517 + WORD $0xf9c81d17; WORD $0x77b020ba // .quad 8624429273841147159 + WORD $0xe51e1566; WORD $0xe896a0d7 // .quad -1686984161281305242 + WORD $0xdc1d122e; WORD $0x0ace1474 // .quad 778582277723329070 + WORD $0xef32cd60; WORD $0x915e2486 // .quad -7971894128441897632 + WORD $0x132456ba; WORD $0x0d819992 // .quad 973227847154161338 + WORD $0xaaff80b8; WORD $0xb5b5ada8 // .quad -5353181642124984136 + WORD $0x97ed6c69; WORD $0x10e1fff6 // .quad 1216534808942701673 + WORD $0xd5bf60e6; WORD $0xe3231912 // .quad -2079791034228842266 + WORD $0x1ef463c1; WORD $0xca8d3ffa // .quad -3851351762838199359 + WORD $0xc5979c8f; WORD $0x8df5efab // .quad -8217398424034108273 + WORD $0xa6b17cb2; WORD $0xbd308ff8 // .quad -4814189703547749198 + WORD $0xb6fd83b3; WORD $0xb1736b96 // .quad -5660062011615247437 + WORD $0xd05ddbde; WORD $0xac7cb3f6 // .quad -6017737129434686498 + WORD $0x64bce4a0; WORD $0xddd0467c // .quad -2463391496091671392 + WORD $0x423aa96b; WORD $0x6bcdf07a // .quad 7768129340171790699 + WORD $0xbef60ee4; WORD $0x8aa22c0d // .quad -8457148712698376476 + WORD $0xd2c953c6; WORD $0x86c16c98 // .quad -8736582398494813242 + WORD $0x2eb3929d; WORD $0xad4ab711 // .quad -5959749872445582691 + WORD $0x077ba8b7; WORD $0xe871c7bf // .quad -1697355961263740745 + WORD $0x7a607744; WORD $0xd89d64d5 // .quad -2838001322129590460 + WORD $0x64ad4972; WORD $0x11471cd7 // .quad 1244995533423855986 + WORD $0x6c7c4a8b; WORD $0x87625f05 // .quad -8691279853972075893 + WORD $0x3dd89bcf; WORD $0xd598e40d // .quad -3055441601647567921 + WORD $0xc79b5d2d; WORD $0xa93af6c6 // .quad -6252413799037706963 + WORD $0x8d4ec2c3; WORD $0x4aff1d10 // .quad 5404070034795315907 + WORD $0x79823479; WORD $0xd389b478 // .quad -3203831230369745799 + WORD $0x585139ba; WORD $0xcedf722a // .quad -3539985255894009414 + WORD $0x4bf160cb; WORD $0x843610cb // .quad -8919923546622172981 + WORD $0xee658828; WORD $0xc2974eb4 // .quad -4424981569867511768 + WORD $0x1eedb8fe; WORD $0xa54394fe // .quad -6538218414850328322 + WORD $0x29feea32; WORD $0x733d2262 // .quad 8303831092947774002 + WORD $0xa6a9273e; WORD $0xce947a3d // .quad -3561087000135522498 + WORD $0x5a3f525f; WORD $0x0806357d // .quad 578208414664970847 + WORD $0x8829b887; WORD $0x811ccc66 // .quad -9143208402725783417 + WORD $0xb0cf26f7; WORD $0xca07c2dc // .quad -3888925500096174345 + WORD $0x2a3426a8; WORD $0xa163ff80 // .quad -6817324484979841368 + WORD $0xdd02f0b5; WORD $0xfc89b393 // .quad -249470856692830027 + WORD $0x34c13052; WORD $0xc9bcff60 // .quad -3909969587797413806 + WORD $0xd443ace2; WORD $0xbbac2078 // .quad -4923524589293425438 + WORD $0x41f17c67; WORD $0xfc2c3f38 // .quad -275775966319379353 + WORD $0x84aa4c0d; WORD $0xd54b944b // .quad -3077202868308390899 + WORD $0x2936edc0; WORD $0x9d9ba783 // .quad -7089889006590693952 + WORD $0x65d4df11; WORD $0x0a9e795e // .quad 765182433041899281 + WORD $0xf384a931; WORD $0xc5029163 // .quad -4250675239810979535 + WORD $0xff4a16d5; WORD $0x4d4617b5 // .quad 5568164059729762005 + WORD $0xf065d37d; WORD $0xf64335bc // .quad -701658031336336515 + WORD $0xbf8e4e45; WORD $0x504bced1 // .quad 5785945546544795205 + WORD $0x163fa42e; WORD $0x99ea0196 // .quad -7356065297226292178 + WORD $0x2f71e1d6; WORD $0xe45ec286 // .quad -1990940103673781802 + WORD $0x9bcf8d39; WORD $0xc06481fb // .quad -4583395603105477319 + WORD $0xbb4e5a4c; WORD $0x5d767327 // .quad 6734696907262548556 + WORD $0x82c37088; WORD $0xf07da27a // .quad -1117558485454458744 + WORD $0xd510f86f; WORD $0x3a6a07f8 // .quad 4209185567039092847 + WORD $0x91ba2655; WORD $0x964e858c // .quad -7616003081050118571 + WORD $0x0a55368b; WORD $0x890489f7 // .quad -8573576096483297653 + WORD $0xb628afea; WORD $0xbbe226ef // .quad -4908317832885260310 + WORD $0xccea842e; WORD $0x2b45ac74 // .quad 3118087934678041646 + WORD $0xa3b2dbe5; WORD $0xeadab0ab // .quad -1523711272679187483 + WORD $0x0012929d; WORD $0x3b0b8bc9 // .quad 4254647968387469981 + WORD $0x464fc96f; WORD $0x92c8ae6b // .quad -7869848573065574033 + WORD $0x40173744; WORD $0x09ce6ebb // .quad 706623942056949572 + WORD $0x17e3bbcb; WORD $0xb77ada06 // .quad -5225624697904579637 + WORD $0x101d0515; WORD $0xcc420a6a // .quad -3728406090856200939 + WORD $0x9ddcaabd; WORD $0xe5599087 // .quad -1920344853953336643 + WORD $0x4a12232d; WORD $0x9fa94682 // .quad -6941939825212513491 + WORD $0xc2a9eab6; WORD $0x8f57fa54 // .quad -8117744561361917258 + WORD $0xdc96abf9; WORD $0x47939822 // .quad 5157633273766521849 + WORD $0xf3546564; WORD $0xb32df8e9 // .quad -5535494683275008668 + WORD $0x93bc56f7; WORD $0x59787e2b // .quad 6447041592208152311 + WORD $0x70297ebd; WORD $0xdff97724 // .quad -2307682335666372931 + WORD $0x3c55b65a; WORD $0x57eb4edb // .quad 6335244004343789146 + WORD $0xc619ef36; WORD $0x8bfbea76 // .quad -8359830487432564938 + WORD $0x0b6b23f1; WORD $0xede62292 // .quad -1304317031425039375 + WORD $0x77a06b03; WORD $0xaefae514 // .quad -5838102090863318269 + WORD $0x8e45eced; WORD $0xe95fab36 // .quad -1630396289281299219 + WORD $0x958885c4; WORD $0xdab99e59 // .quad -2685941595151759932 + WORD $0x18ebb414; WORD $0x11dbcb02 // .quad 1286845328412881940 + WORD $0xfd75539b; WORD $0x88b402f7 // .quad -8596242524610931813 + WORD $0x9f26a119; WORD $0xd652bdc2 // .quad -3003129357911285479 + WORD $0xfcd2a881; WORD $0xaae103b5 // .quad -6133617137336276863 + WORD $0x46f0495f; WORD $0x4be76d33 // .quad 5469460339465668959 + WORD $0x7c0752a2; WORD $0xd59944a3 // .quad -3055335403242958174 + WORD $0x0c562ddb; WORD $0x6f70a440 // .quad 8030098730593431003 + WORD $0x2d8493a5; WORD $0x857fcae6 // .quad -8827113654667930715 + WORD $0x0f6bb952; WORD $0xcb4ccd50 // .quad -3797434642040374958 + WORD $0xb8e5b88e; WORD $0xa6dfbd9f // .quad -6422206049907525490 + WORD $0x1346a7a7; WORD $0x7e2000a4 // .quad 9088264752731695015 + WORD $0xa71f26b2; WORD $0xd097ad07 // .quad -3416071543957018958 + WORD $0x8c0c28c8; WORD $0x8ed40066 // .quad -8154892584824854328 + WORD $0xc873782f; WORD $0x825ecc24 // .quad -9052573742614218705 + WORD $0x2f0f32fa; WORD $0x72890080 // .quad 8253128342678483706 + WORD $0xfa90563b; WORD $0xa2f67f2d // .quad -6704031159840385477 + WORD $0x3ad2ffb9; WORD $0x4f2b40a0 // .quad 5704724409920716729 + WORD $0x79346bca; WORD $0xcbb41ef9 // .quad -3768352931373093942 + WORD $0x4987bfa8; WORD $0xe2f610c8 // .quad -2092466524453879896 + WORD $0xd78186bc; WORD $0xfea126b7 // .quad -98755145788979524 + WORD $0x2df4d7c9; WORD $0x0dd9ca7d // .quad 998051431430019017 + WORD $0xe6b0f436; WORD $0x9f24b832 // .quad -6979250993759194058 + WORD $0x79720dbb; WORD $0x91503d1c // .quad -7975807747567252037 + WORD $0xa05d3143; WORD $0xc6ede63f // .quad -4112377723771604669 + WORD $0x97ce912a; WORD $0x75a44c63 // .quad 8476984389250486570 + WORD $0x88747d94; WORD $0xf8a95fcf // .quad -528786136287117932 + WORD $0x3ee11aba; WORD $0xc986afbe // .quad -3925256793573221702 + WORD $0xb548ce7c; WORD $0x9b69dbe1 // .quad -7248020362820530564 + WORD $0xce996168; WORD $0xfbe85bad // .quad -294884973539139224 + WORD $0x229b021b; WORD $0xc24452da // .quad -4448339435098275301 + WORD $0x423fb9c3; WORD $0xfae27299 // .quad -368606216923924029 + WORD $0xab41c2a2; WORD $0xf2d56790 // .quad -948738275445456222 + WORD $0xc967d41a; WORD $0xdccd879f // .quad -2536221894791146470 + WORD $0x6b0919a5; WORD $0x97c560ba // .quad -7510490449794491995 + WORD $0xbbc1c920; WORD $0x5400e987 // .quad 6053094668365842720 + WORD $0x05cb600f; WORD $0xbdb6b8e9 // .quad -4776427043815727089 + WORD $0xaab23b68; WORD $0x290123e9 // .quad 2954682317029915496 + WORD $0x473e3813; WORD $0xed246723 // .quad -1358847786342270957 + WORD $0x0aaf6521; WORD $0xf9a0b672 // .quad -459166561069996767 + WORD $0x0c86e30b; WORD $0x9436c076 // .quad -7766808894105001205 + WORD $0x8d5b3e69; WORD $0xf808e40e // .quad -573958201337495959 + WORD $0x8fa89bce; WORD $0xb9447093 // .quad -5096825099203863602 + WORD $0x30b20e04; WORD $0xb60b1d12 // .quad -5329133770099257852 + WORD $0x7392c2c2; WORD $0xe7958cb8 // .quad -1759345355577441598 + WORD $0x5e6f48c2; WORD $0xb1c6f22b // .quad -5636551615525730110 + WORD $0x483bb9b9; WORD $0x90bd77f3 // .quad -8017119874876982855 + WORD $0x360b1af3; WORD $0x1e38aeb6 // .quad 2177682517447613171 + WORD $0x1a4aa828; WORD $0xb4ecd5f0 // .quad -5409713825168840664 + WORD $0xc38de1b0; WORD $0x25c6da63 // .quad 2722103146809516464 + WORD $0x20dd5232; WORD $0xe2280b6c // .quad -2150456263033662926 + WORD $0x5a38ad0e; WORD $0x579c487e // .quad 6313000485183335694 + WORD $0x948a535f; WORD $0x8d590723 // .quad -8261564192037121185 + WORD $0xf0c6d851; WORD $0x2d835a9d // .quad 3279564588051781713 + WORD $0x79ace837; WORD $0xb0af48ec // .quad -5715269221619013577 + WORD $0x6cf88e65; WORD $0xf8e43145 // .quad -512230283362660763 + WORD $0x98182244; WORD $0xdcdb1b27 // .quad -2532400508596379068 + WORD $0x641b58ff; WORD $0x1b8e9ecb // .quad 1985699082112030975 + WORD $0xbf0f156b; WORD $0x8a08f0f8 // .quad -8500279345513818773 + WORD $0x3d222f3f; WORD $0xe272467e // .quad -2129562165787349185 + WORD $0xeed2dac5; WORD $0xac8b2d36 // .quad -6013663163464885563 + WORD $0xcc6abb0f; WORD $0x5b0ed81d // .quad 6561419329620589327 + WORD $0xaa879177; WORD $0xd7adf884 // .quad -2905392935903719049 + WORD $0x9fc2b4e9; WORD $0x98e94712 // .quad -7428327965055601431 + WORD $0xea94baea; WORD $0x86ccbb52 // .quad -8733399612580906262 + WORD $0x47b36224; WORD $0x3f2398d7 // .quad 4549648098962661924 + WORD $0xa539e9a5; WORD $0xa87fea27 // .quad -6305063497298744923 + WORD $0x19a03aad; WORD $0x8eec7f0d // .quad -8147997931578836307 + WORD $0x8e88640e; WORD $0xd29fe4b1 // .quad -3269643353196043250 + WORD $0x300424ac; WORD $0x1953cf68 // .quad 1825030320404309164 + WORD $0xf9153e89; WORD $0x83a3eeee // .quad -8961056123388608887 + WORD $0x3c052dd7; WORD $0x5fa8c342 // .quad 6892973918932774359 + WORD $0xb75a8e2b; WORD $0xa48ceaaa // .quad -6589634135808373205 + WORD $0xcb06794d; WORD $0x3792f412 // .quad 4004531380238580045 + WORD $0x653131b6; WORD $0xcdb02555 // .quad -3625356651333078602 + WORD $0xbee40bd0; WORD $0xe2bbd88b // .quad -2108853905778275376 + WORD $0x5f3ebf11; WORD $0x808e1755 // .quad -9183376934724255983 + WORD $0xae9d0ec4; WORD $0x5b6aceae // .quad 6587304654631931588 + WORD $0xb70e6ed6; WORD $0xa0b19d2a // .quad -6867535149977932074 + WORD $0x5a445275; WORD $0xf245825a // .quad -989241218564861323 + WORD $0x64d20a8b; WORD $0xc8de0475 // .quad -3972732919045027189 + WORD $0xf0d56712; WORD $0xeed6e2f0 // .quad -1236551523206076654 + WORD $0xbe068d2e; WORD $0xfb158592 // .quad -354230130378896082 + WORD $0x9685606b; WORD $0x55464dd6 // .quad 6144684325637283947 + WORD $0xb6c4183d; WORD $0x9ced737b // .quad -7138922859127891907 + WORD $0x3c26b886; WORD $0xaa97e14c // .quad -6154202648235558778 + WORD $0xa4751e4c; WORD $0xc428d05a // .quad -4311967555482476980 + WORD $0x4b3066a8; WORD $0xd53dd99f // .quad -3081067291867060568 + WORD $0x4d9265df; WORD $0xf5330471 // .quad -778273425925708321 + WORD $0x8efe4029; WORD $0xe546a803 // .quad -1925667057416912855 + WORD $0xd07b7fab; WORD $0x993fe2c6 // .quad -7403949918844649557 + WORD $0x72bdd033; WORD $0xde985204 // .quad -2407083821771141069 + WORD $0x849a5f96; WORD $0xbf8fdb78 // .quad -4643251380128424042 + WORD $0x8f6d4440; WORD $0x963e6685 // .quad -7620540795641314240 + WORD $0xa5c0f77c; WORD $0xef73d256 // .quad -1192378206733142148 + WORD $0x79a44aa8; WORD $0xdde70013 // .quad -2456994988062127448 + WORD $0x27989aad; WORD $0x95a86376 // .quad -7662765406849295699 + WORD $0x580d5d52; WORD $0x5560c018 // .quad 6152128301777116498 + WORD $0xb17ec159; WORD $0xbb127c53 // .quad -4966770740134231719 + WORD $0x6e10b4a6; WORD $0xaab8f01e // .quad -6144897678060768090 + WORD $0x9dde71af; WORD $0xe9d71b68 // .quad -1596777406740401745 + WORD $0x04ca70e8; WORD $0xcab39613 // .quad -3840561048787980056 + WORD $0x62ab070d; WORD $0x92267121 // .quad -7915514906853832947 + WORD $0xc5fd0d22; WORD $0x3d607b97 // .quad 4422670725869800738 + WORD $0xbb55c8d1; WORD $0xb6b00d69 // .quad -5282707615139903279 + WORD $0xb77c506a; WORD $0x8cb89a7d // .quad -8306719647944912790 + WORD $0x2a2b3b05; WORD $0xe45c10c4 // .quad -1991698500497491195 + WORD $0x92adb242; WORD $0x77f3608e // .quad 8643358275316593218 + WORD $0x9a5b04e3; WORD $0x8eb98a7a // .quad -8162340590452013853 + WORD $0x37591ed3; WORD $0x55f038b2 // .quad 6192511825718353619 + WORD $0x40f1c61c; WORD $0xb267ed19 // .quad -5591239719637629412 + WORD $0xc52f6688; WORD $0x6b6c46de // .quad 7740639782147942024 + WORD $0x912e37a3; WORD $0xdf01e85f // .quad -2377363631119648861 + WORD $0x3b3da015; WORD $0x2323ac4b // .quad 2532056854628769813 + WORD $0xbabce2c6; WORD $0x8b61313b // .quad -8403381297090862394 + WORD $0x0a0d081a; WORD $0xabec975e // .quad -6058300968568813542 + WORD $0xa96c1b77; WORD $0xae397d8a // .quad -5892540602936190089 + WORD $0x8c904a21; WORD $0x96e7bd35 // .quad -7572876210711016927 + WORD $0x53c72255; WORD $0xd9c7dced // .quad -2753989735242849707 + WORD $0x77da2e54; WORD $0x7e50d641 // .quad 9102010423587778132 + WORD $0x545c7575; WORD $0x881cea14 // .quad -8638772612167862923 + WORD $0xd5d0b9e9; WORD $0xdde50bd1 // .quad -2457545025797441047 + WORD $0x697392d2; WORD $0xaa242499 // .quad -6186779746782440750 + WORD $0x4b44e864; WORD $0x955e4ec6 // .quad -7683617300674189212 + WORD $0xc3d07787; WORD $0xd4ad2dbf // .quad -3121788665050663033 + WORD $0xef0b113e; WORD $0xbd5af13b // .quad -4802260812921368258 + WORD $0xda624ab4; WORD $0x84ec3c97 // .quad -8868646943297746252 + WORD $0xeacdd58e; WORD $0xecb1ad8a // .quad -1391139997724322418 + WORD $0xd0fadd61; WORD $0xa6274bbd // .quad -6474122660694794911 + WORD $0xa5814af2; WORD $0x67de18ed // .quad 7484447039699372786 + WORD $0x453994ba; WORD $0xcfb11ead // .quad -3480967307441105734 + WORD $0x8770ced7; WORD $0x80eacf94 // .quad -9157278655470055721 + WORD $0x4b43fcf4; WORD $0x81ceb32c // .quad -9093133594791772940 + WORD $0xa94d028d; WORD $0xa1258379 // .quad -6834912300910181747 + WORD $0x5e14fc31; WORD $0xa2425ff7 // .quad -6754730975062328271 + WORD $0x13a04330; WORD $0x096ee458 // .quad 679731660717048624 + WORD $0x359a3b3e; WORD $0xcad2f7f5 // .quad -3831727700400522434 + WORD $0x188853fc; WORD $0x8bca9d6e // .quad -8373707460958465028 + WORD $0x8300ca0d; WORD $0xfd87b5f2 // .quad -177973607073265139 + WORD $0xcf55347d; WORD $0x775ea264 // .quad 8601490892183123069 + WORD $0x91e07e48; WORD $0x9e74d1b7 // .quad -7028762532061872568 + WORD $0x032a819d; WORD $0x95364afe // .quad -7694880458480647779 + WORD $0x76589dda; WORD $0xc6120625 // .quad -4174267146649952806 + WORD $0x83f52204; WORD $0x3a83ddbd // .quad 4216457482181353988 + WORD $0xd3eec551; WORD $0xf79687ae // .quad -606147914885053103 + WORD $0x72793542; WORD $0xc4926a96 // .quad -4282243101277735614 + WORD $0x44753b52; WORD $0x9abe14cd // .quad -7296371474444240046 + WORD $0x0f178293; WORD $0x75b7053c // .quad 8482254178684994195 + WORD $0x95928a27; WORD $0xc16d9a00 // .quad -4508778324627912153 + WORD $0x12dd6338; WORD $0x5324c68b // .quad 5991131704928854840 + WORD $0xbaf72cb1; WORD $0xf1c90080 // .quad -1024286887357502287 + WORD $0xebca5e03; WORD $0xd3f6fc16 // .quad -3173071712060547581 + WORD $0x74da7bee; WORD $0x971da050 // .quad -7557708332239520786 + WORD $0xa6bcf584; WORD $0x88f4bb1c // .quad -8578025658503072380 + WORD $0x92111aea; WORD $0xbce50864 // .quad -4835449396872013078 + WORD $0xd06c32e5; WORD $0x2b31e9e3 // .quad 3112525982153323237 + WORD $0xb69561a5; WORD $0xec1e4a7d // .quad -1432625727662628443 + WORD $0x62439fcf; WORD $0x3aff322e // .quad 4251171748059520975 + WORD $0x921d5d07; WORD $0x9392ee8e // .quad -7812920107430224633 + WORD $0xfad487c2; WORD $0x09befeb9 // .quad 702278666647013314 + WORD $0x36a4b449; WORD $0xb877aa32 // .quad -5154464115860392887 + WORD $0x7989a9b3; WORD $0x4c2ebe68 // .quad 5489534351736154547 + WORD $0xc44de15b; WORD $0xe69594be // .quad -1831394126398103205 + WORD $0x4bf60a10; WORD $0x0f9d3701 // .quad 1125115960621402640 + WORD $0x3ab0acd9; WORD $0x901d7cf7 // .quad -8062150356639896359 + WORD $0x9ef38c94; WORD $0x538484c1 // .quad 6018080969204141204 + WORD $0x095cd80f; WORD $0xb424dc35 // .quad -5466001927372482545 + WORD $0x06b06fb9; WORD $0x2865a5f2 // .quad 2910915193077788601 + WORD $0x4bb40e13; WORD $0xe12e1342 // .quad -2220816390788215277 + WORD $0x442e45d3; WORD $0xf93f87b7 // .quad -486521013540076077 + WORD $0x6f5088cb; WORD $0x8cbccc09 // .quad -8305539271883716405 + WORD $0x1539d748; WORD $0xf78f69a5 // .quad -608151266925095096 + WORD $0xcb24aafe; WORD $0xafebff0b // .quad -5770238071427257602 + WORD $0x5a884d1b; WORD $0xb573440e // .quad -5371875102083756773 + WORD $0xbdedd5be; WORD $0xdbe6fece // .quad -2601111570856684098 + WORD $0xf8953030; WORD $0x31680a88 // .quad 3560107088838733872 + WORD $0x36b4a597; WORD $0x89705f41 // .quad -8543223759426509417 + WORD $0x36ba7c3d; WORD $0xfdc20d2b // .quad -161552157378970563 + WORD $0x8461cefc; WORD $0xabcc7711 // .quad -6067343680855748868 + WORD $0x04691b4c; WORD $0x3d329076 // .quad 4409745821703674700 + WORD $0xe57a42bc; WORD $0xd6bf94d5 // .quad -2972493582642298180 + WORD $0xc2c1b10f; WORD $0xa63f9a49 // .quad -6467280898289979121 + WORD $0xaf6c69b5; WORD $0x8637bd05 // .quad -8775337516792518219 + WORD $0x33721d53; WORD $0x0fcf80dc // .quad 1139270913992301907 + WORD $0x1b478423; WORD $0xa7c5ac47 // .quad -6357485877563259869 + WORD $0x404ea4a8; WORD $0xd3c36113 // .quad -3187597375937010520 + WORD $0xe219652b; WORD $0xd1b71758 // .quad -3335171328526686933 + WORD $0x083126e9; WORD $0x645a1cac // .quad 7231123676894144233 + WORD $0x8d4fdf3b; WORD $0x83126e97 // .quad -9002011107970261189 + WORD $0x0a3d70a3; WORD $0x3d70a3d7 // .quad 4427218577690292387 + WORD $0x70a3d70a; WORD $0xa3d70a3d // .quad -6640827866535438582 + WORD $0xcccccccc // .space 4, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc' + WORD $0xcccccccc // .space 4, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc' + WORD $0xcccccccc // .space 4, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc' + WORD $0xcccccccc // .space 4, '\xcc\xcc\xcc\xcc' + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x80000000 // .quad -9223372036854775808 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xa0000000 // .quad -6917529027641081856 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xc8000000 // .quad -4035225266123964416 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xfa000000 // .quad -432345564227567616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x9c400000 // .quad -7187745005283311616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xc3500000 // .quad -4372995238176751616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xf4240000 // .quad -854558029293551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x98968000 // .quad -7451627795949551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xbebc2000 // .quad -4702848726509551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xee6b2800 // .quad -1266874889709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x9502f900 // .quad -7709325833709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xba43b740 // .quad -5024971273709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0xe8d4a510 // .quad -1669528073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x00000000; WORD $0x9184e72a // .quad -7960984073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x80000000; WORD $0xb5e620f4 // .quad -5339544073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xa0000000; WORD $0xe35fa931 // .quad -2062744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x04000000; WORD $0x8e1bc9bf // .quad -8206744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xc5000000; WORD $0xb1a2bc2e // .quad -5646744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x76400000; WORD $0xde0b6b3a // .quad -2446744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x89e80000; WORD $0x8ac72304 // .quad -8446744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xac620000; WORD $0xad78ebc5 // .quad -5946744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x177a8000; WORD $0xd8d726b7 // .quad -2821744073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x6eac9000; WORD $0x87867832 // .quad -8681119073709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x0a57b400; WORD $0xa968163f // .quad -6239712823709551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xcceda100; WORD $0xd3c21bce // .quad -3187955011209551616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x401484a0; WORD $0x84595161 // .quad -8910000909647051616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0x9019a5c8; WORD $0xa56fa5b9 // .quad -6525815118631426616 + WORD $0x00000000; WORD $0x00000000 // .quad 0 + WORD $0xf4200f3a; WORD $0xcecb8f27 // .quad -3545582879861895366 + WORD $0x00000000; WORD $0x40000000 // .quad 4611686018427387904 + WORD $0xf8940984; WORD $0x813f3978 // .quad -9133518327554766460 + WORD $0x00000000; WORD $0x50000000 // .quad 5764607523034234880 + WORD $0x36b90be5; WORD $0xa18f07d7 // .quad -6805211891016070171 + WORD $0x00000000; WORD $0xa4000000 // .quad -6629298651489370112 + WORD $0x04674ede; WORD $0xc9f2c9cd // .quad -3894828845342699810 + WORD $0x00000000; WORD $0x4d000000 // .quad 5548434740920451072 + WORD $0x45812296; WORD $0xfc6f7c40 // .quad -256850038250986858 + WORD $0x00000000; WORD $0xf0200000 // .quad -1143914305352105984 + WORD $0x2b70b59d; WORD $0x9dc5ada8 // .quad -7078060301547948643 + WORD $0x00000000; WORD $0x6c280000 // .quad 7793479155164643328 + WORD $0x364ce305; WORD $0xc5371912 // .quad -4235889358507547899 + WORD $0x00000000; WORD $0xc7320000 // .quad -4093209111326359552 + WORD $0xc3e01bc6; WORD $0xf684df56 // .quad -683175679707046970 + WORD $0x00000000; WORD $0x3c7f4000 // .quad 4359273333062107136 + WORD $0x3a6c115c; WORD $0x9a130b96 // .quad -7344513827457986212 + WORD $0x00000000; WORD $0x4b9f1000 // .quad 5449091666327633920 + WORD $0xc90715b3; WORD $0xc097ce7b // .quad -4568956265895094861 + WORD $0x00000000; WORD $0x1e86d400 // .quad 2199678564482154496 + WORD $0xbb48db20; WORD $0xf0bdc21a // .quad -1099509313941480672 + WORD $0x00000000; WORD $0x13144480 // .quad 1374799102801346560 + WORD $0xb50d88f4; WORD $0x96769950 // .quad -7604722348854507276 + WORD $0x00000000; WORD $0x17d955a0 // .quad 1718498878501683200 + WORD $0xe250eb31; WORD $0xbc143fa4 // .quad -4894216917640746191 + WORD $0x00000000; WORD $0x5dcfab08 // .quad 6759809616554491904 + WORD $0x1ae525fd; WORD $0xeb194f8e // .quad -1506085128623544835 + WORD $0x00000000; WORD $0x5aa1cae5 // .quad 6530724019560251392 + WORD $0xd0cf37be; WORD $0x92efd1b8 // .quad -7858832233030797378 + WORD $0x40000000; WORD $0xf14a3d9e // .quad -1059967012404461568 + WORD $0x050305ad; WORD $0xb7abc627 // .quad -5211854272861108819 + WORD $0xd0000000; WORD $0x6d9ccd05 // .quad 7898413271349198848 + WORD $0xc643c719; WORD $0xe596b7b0 // .quad -1903131822648998119 + WORD $0xa2000000; WORD $0xe4820023 // .quad -1981020733047832576 + WORD $0x7bea5c6f; WORD $0x8f7e32ce // .quad -8106986416796705681 + WORD $0x8a800000; WORD $0xdda2802c // .quad -2476275916309790720 + WORD $0x1ae4f38b; WORD $0xb35dbf82 // .quad -5522047002568494197 + WORD $0xad200000; WORD $0xd50b2037 // .quad -3095344895387238400 + WORD $0xa19e306e; WORD $0xe0352f62 // .quad -2290872734783229842 + WORD $0xcc340000; WORD $0x4526f422 // .quad 4982938468024057856 + WORD $0xa502de45; WORD $0x8c213d9d // .quad -8349324486880600507 + WORD $0x7f410000; WORD $0x9670b12b // .quad -7606384970252091392 + WORD $0x0e4395d6; WORD $0xaf298d05 // .quad -5824969590173362730 + WORD $0x5f114000; WORD $0x3c0cdd76 // .quad 4327076842467049472 + WORD $0x51d47b4c; WORD $0xdaf3f046 // .quad -2669525969289315508 + WORD $0xfb6ac800; WORD $0xa5880a69 // .quad -6518949010312869888 + WORD $0xf324cd0f; WORD $0x88d8762b // .quad -8585982758446904049 + WORD $0x7a457a00; WORD $0x8eea0d04 // .quad -8148686262891087360 + WORD $0xefee0053; WORD $0xab0e93b6 // .quad -6120792429631242157 + WORD $0x98d6d880; WORD $0x72a49045 // .quad 8260886245095692416 + WORD $0xabe98068; WORD $0xd5d238a4 // .quad -3039304518611664792 + WORD $0x7f864750; WORD $0x47a6da2b // .quad 5163053903184807760 + WORD $0xeb71f041; WORD $0x85a36366 // .quad -8817094351773372351 + WORD $0x5f67d924; WORD $0x999090b6 // .quad -7381240676301154012 + WORD $0xa64e6c51; WORD $0xa70c3c40 // .quad -6409681921289327535 + WORD $0xf741cf6d; WORD $0xfff4b4e3 // .quad -3178808521666707 + WORD $0xcfe20765; WORD $0xd0cf4b50 // .quad -3400416383184271515 + WORD $0x7a8921a4; WORD $0xbff8f10e // .quad -4613672773753429596 + WORD $0x81ed449f; WORD $0x82818f12 // .quad -9042789267131251553 + WORD $0x192b6a0d; WORD $0xaff72d52 // .quad -5767090967191786995 + WORD $0x226895c7; WORD $0xa321f2d7 // .quad -6691800565486676537 + WORD $0x9f764490; WORD $0x9bf4f8a6 // .quad -7208863708989733744 + WORD $0xeb02bb39; WORD $0xcbea6f8c // .quad -3753064688430957767 + WORD $0x4753d5b4; WORD $0x02f236d0 // .quad 212292400617608628 + WORD $0x25c36a08; WORD $0xfee50b70 // .quad -79644842111309304 + WORD $0x2c946590; WORD $0x01d76242 // .quad 132682750386005392 + WORD $0x179a2245; WORD $0x9f4f2726 // .quad -6967307053960650171 + WORD $0xb7b97ef5; WORD $0x424d3ad2 // .quad 4777539456409894645 + WORD $0x9d80aad6; WORD $0xc722f0ef // .quad -4097447799023424810 + WORD $0x65a7deb2; WORD $0xd2e08987 // .quad -3251447716342407502 + WORD $0x84e0d58b; WORD $0xf8ebad2b // .quad -510123730351893109 + WORD $0x9f88eb2f; WORD $0x63cc55f4 // .quad 7191217214140771119 + WORD $0x330c8577; WORD $0x9b934c3b // .quad -7236356359111015049 + WORD $0xc76b25fb; WORD $0x3cbf6b71 // .quad 4377335499248575995 + WORD $0xffcfa6d5; WORD $0xc2781f49 // .quad -4433759430461380907 + WORD $0x3945ef7a; WORD $0x8bef464e // .quad -8363388681221443718 + WORD $0x7fc3908a; WORD $0xf316271c // .quad -930513269649338230 + WORD $0xe3cbb5ac; WORD $0x97758bf0 // .quad -7532960934977096276 + WORD $0xcfda3a56; WORD $0x97edd871 // .quad -7499099821171918250 + WORD $0x1cbea317; WORD $0x3d52eeed // .quad 4418856886560793367 + WORD $0x43d0c8ec; WORD $0xbde94e8e // .quad -4762188758037509908 + WORD $0x63ee4bdd; WORD $0x4ca7aaa8 // .quad 5523571108200991709 + WORD $0xd4c4fb27; WORD $0xed63a231 // .quad -1341049929119499481 + WORD $0x3e74ef6a; WORD $0x8fe8caa9 // .quad -8076983103442849942 + WORD $0x24fb1cf8; WORD $0x945e455f // .quad -7755685233340769032 + WORD $0x8e122b44; WORD $0xb3e2fd53 // .quad -5484542860876174524 + WORD $0xee39e436; WORD $0xb975d6b6 // .quad -5082920523248573386 + WORD $0x7196b616; WORD $0x60dbbca8 // .quad 6979379479186945558 + WORD $0xa9c85d44; WORD $0xe7d34c64 // .quad -1741964635633328828 + WORD $0x46fe31cd; WORD $0xbc8955e9 // .quad -4861259862362934835 + WORD $0xea1d3a4a; WORD $0x90e40fbe // .quad -8006256924911912374 + WORD $0x98bdbe41; WORD $0x6babab63 // .quad 7758483227328495169 + WORD $0xa4a488dd; WORD $0xb51d13ae // .quad -5396135137712502563 + WORD $0x7eed2dd1; WORD $0xc696963c // .quad -4136954021121544751 + WORD $0x4dcdab14; WORD $0xe264589a // .quad -2133482903713240300 + WORD $0xcf543ca2; WORD $0xfc1e1de5 // .quad -279753253987271518 + WORD $0x70a08aec; WORD $0x8d7eb760 // .quad -8250955842461857044 + WORD $0x43294bcb; WORD $0x3b25a55f // .quad 4261994450943298507 + WORD $0x8cc8ada8; WORD $0xb0de6538 // .quad -5702008784649933400 + WORD $0x13f39ebe; WORD $0x49ef0eb7 // .quad 5327493063679123134 + WORD $0xaffad912; WORD $0xdd15fe86 // .quad -2515824962385028846 + WORD $0x6c784337; WORD $0x6e356932 // .quad 7941369183226839863 + WORD $0x2dfcc7ab; WORD $0x8a2dbf14 // .quad -8489919629131724885 + WORD $0x07965404; WORD $0x49c2c37f // .quad 5315025460606161924 + WORD $0x397bf996; WORD $0xacb92ed9 // .quad -6000713517987268202 + WORD $0xc97be906; WORD $0xdc33745e // .quad -2579590211097073402 + WORD $0x87daf7fb; WORD $0xd7e77a8f // .quad -2889205879056697349 + WORD $0x3ded71a3; WORD $0x69a028bb // .quad 7611128154919104931 + WORD $0xb4e8dafd; WORD $0x86f0ac99 // .quad -8723282702051517699 + WORD $0x0d68ce0c; WORD $0xc40832ea // .quad -4321147861633282548 + WORD $0x222311bc; WORD $0xa8acd7c0 // .quad -6292417359137009220 + WORD $0x90c30190; WORD $0xf50a3fa4 // .quad -789748808614215280 + WORD $0x2aabd62b; WORD $0xd2d80db0 // .quad -3253835680493873621 + WORD $0xda79e0fa; WORD $0x792667c6 // .quad 8729779031470891258 + WORD $0x1aab65db; WORD $0x83c7088e // .quad -8951176327949752869 + WORD $0x91185938; WORD $0x577001b8 // .quad 6300537770911226168 + WORD $0xa1563f52; WORD $0xa4b8cab1 // .quad -6577284391509803182 + WORD $0xb55e6f86; WORD $0xed4c0226 // .quad -1347699823215743098 + WORD $0x09abcf26; WORD $0xcde6fd5e // .quad -3609919470959866074 + WORD $0x315b05b4; WORD $0x544f8158 // .quad 6075216638131242420 + WORD $0xc60b6178; WORD $0x80b05e5a // .quad -9173728696990998152 + WORD $0x3db1c721; WORD $0x696361ae // .quad 7594020797664053025 + WORD $0x778e39d6; WORD $0xa0dc75f1 // .quad -6855474852811359786 + WORD $0xcd1e38e9; WORD $0x03bc3a19 // .quad 269153960225290473 + WORD $0xd571c84c; WORD $0xc913936d // .quad -3957657547586811828 + WORD $0x4065c723; WORD $0x04ab48a0 // .quad 336442450281613091 + WORD $0x4ace3a5f; WORD $0xfb587849 // .quad -335385916056126881 + WORD $0x283f9c76; WORD $0x62eb0d64 // .quad 7127805559067090038 + WORD $0xcec0e47b; WORD $0x9d174b2d // .quad -7127145225176161157 + WORD $0x324f8394; WORD $0x3ba5d0bd // .quad 4298070930406474644 + WORD $0x42711d9a; WORD $0xc45d1df9 // .quad -4297245513042813542 + WORD $0x7ee36479; WORD $0xca8f44ec // .quad -3850783373846682503 + WORD $0x930d6500; WORD $0xf5746577 // .quad -759870872876129024 + WORD $0xcf4e1ecb; WORD $0x7e998b13 // .quad 9122475437414293195 + WORD $0xbbe85f20; WORD $0x9968bf6a // .quad -7392448323188662496 + WORD $0xc321a67e; WORD $0x9e3fedd8 // .quad -7043649776941685122 + WORD $0x6ae276e8; WORD $0xbfc2ef45 // .quad -4628874385558440216 + WORD $0xf3ea101e; WORD $0xc5cfe94e // .quad -4192876202749718498 + WORD $0xc59b14a2; WORD $0xefb3ab16 // .quad -1174406963520662366 + WORD $0x58724a12; WORD $0xbba1f1d1 // .quad -4926390635932268014 + WORD $0x3b80ece5; WORD $0x95d04aee // .quad -7651533379841495835 + WORD $0xae8edc97; WORD $0x2a8a6e45 // .quad 3065383741939440791 + WORD $0xca61281f; WORD $0xbb445da9 // .quad -4952730706374481889 + WORD $0x1a3293bd; WORD $0xf52d09d7 // .quad -779956341003086915 + WORD $0x3cf97226; WORD $0xea157514 // .quad -1579227364540714458 + WORD $0x705f9c56; WORD $0x593c2626 // .quad 6430056314514152534 + WORD $0xa61be758; WORD $0x924d692c // .quad -7904546130479028392 + WORD $0x0c77836c; WORD $0x6f8b2fb0 // .quad 8037570393142690668 + WORD $0xcfa2e12e; WORD $0xb6e0c377 // .quad -5268996644671397586 + WORD $0x0f956447; WORD $0x0b6dfb9c // .quad 823590954573587527 + WORD $0xc38b997a; WORD $0xe498f455 // .quad -1974559787411859078 + WORD $0x89bd5eac; WORD $0x4724bd41 // .quad 5126430365035880108 + WORD $0x9a373fec; WORD $0x8edf98b5 // .quad -8151628894773493780 + WORD $0xec2cb657; WORD $0x58edec91 // .quad 6408037956294850135 + WORD $0x00c50fe7; WORD $0xb2977ee3 // .quad -5577850100039479321 + WORD $0x6737e3ed; WORD $0x2f2967b6 // .quad 3398361426941174765 + WORD $0xc0f653e1; WORD $0xdf3d5e9b // .quad -2360626606621961247 + WORD $0x0082ee74; WORD $0xbd79e0d2 // .quad -4793553135802847628 + WORD $0x5899f46c; WORD $0x8b865b21 // .quad -8392920656779807636 + WORD $0x80a3aa11; WORD $0xecd85906 // .quad -1380255401326171631 + WORD $0xaec07187; WORD $0xae67f1e9 // .quad -5879464802547371641 + WORD $0x20cc9495; WORD $0xe80e6f48 // .quad -1725319251657714539 + WORD $0x1a708de9; WORD $0xda01ee64 // .quad -2737644984756826647 + WORD $0x147fdcdd; WORD $0x3109058d // .quad 3533361486141316317 + WORD $0x908658b2; WORD $0x884134fe // .quad -8628557143114098510 + WORD $0x599fd415; WORD $0xbd4b46f0 // .quad -4806670179178130411 + WORD $0x34a7eede; WORD $0xaa51823e // .quad -6174010410465235234 + WORD $0x7007c91a; WORD $0x6c9e18ac // .quad 7826720331309500698 + WORD $0xc1d1ea96; WORD $0xd4e5e2cd // .quad -3105826994654156138 + WORD $0xc604ddb0; WORD $0x03e2cf6b // .quad 280014188641050032 + WORD $0x9923329e; WORD $0x850fadc0 // .quad -8858670899299929442 + WORD $0xb786151c; WORD $0x84db8346 // .quad -8873354301053463268 + WORD $0xbf6bff45; WORD $0xa6539930 // .quad -6461652605697523899 + WORD $0x65679a63; WORD $0xe6126418 // .quad -1868320839462053277 + WORD $0xef46ff16; WORD $0xcfe87f7c // .quad -3465379738694516970 + WORD $0x3f60c07e; WORD $0x4fcb7e8f // .quad 5749828502977298558 + WORD $0x158c5f6e; WORD $0x81f14fae // .quad -9083391364325154962 + WORD $0x0f38f09d; WORD $0xe3be5e33 // .quad -2036086408133152611 + WORD $0x9aef7749; WORD $0xa26da399 // .quad -6742553186979055799 + WORD $0xd3072cc5; WORD $0x5cadf5bf // .quad 6678264026688335045 + WORD $0x01ab551c; WORD $0xcb090c80 // .quad -3816505465296431844 + WORD $0xc7c8f7f6; WORD $0x73d9732f // .quad 8347830033360418806 + WORD $0x02162a63; WORD $0xfdcb4fa0 // .quad -158945813193151901 + WORD $0xdcdd9afa; WORD $0x2867e7fd // .quad 2911550761636567802 + WORD $0x014dda7e; WORD $0x9e9f11c4 // .quad -7016870160886801794 + WORD $0x541501b8; WORD $0xb281e1fd // .quad -5583933584809066056 + WORD $0x01a1511d; WORD $0xc646d635 // .quad -4159401682681114339 + WORD $0xa91a4226; WORD $0x1f225a7c // .quad 2243455055843443238 + WORD $0x4209a565; WORD $0xf7d88bc2 // .quad -587566084924005019 + WORD $0xe9b06958; WORD $0x3375788d // .quad 3708002419115845976 + WORD $0x6946075f; WORD $0x9ae75759 // .quad -7284757830718584993 + WORD $0x641c83ae; WORD $0x0052d6b1 // .quad 23317005467419566 + WORD $0xc3978937; WORD $0xc1a12d2f // .quad -4494261269970843337 + WORD $0xbd23a49a; WORD $0xc0678c5d // .quad -4582539761593113446 + WORD $0xb47d6b84; WORD $0xf209787b // .quad -1006140569036166268 + WORD $0x963646e0; WORD $0xf840b7ba // .quad -558244341782001952 + WORD $0x50ce6332; WORD $0x9745eb4d // .quad -7546366883288685774 + WORD $0x3bc3d898; WORD $0xb650e5a9 // .quad -5309491445654890344 + WORD $0xa501fbff; WORD $0xbd176620 // .quad -4821272585683469313 + WORD $0x8ab4cebe; WORD $0xa3e51f13 // .quad -6636864307068612930 + WORD $0xce427aff; WORD $0xec5d3fa8 // .quad -1414904713676948737 + WORD $0x36b10137; WORD $0xc66f336c // .quad -4148040191917883081 + WORD $0x80e98cdf; WORD $0x93ba47c9 // .quad -7801844473689174817 + WORD $0x445d4184; WORD $0xb80b0047 // .quad -5185050239897353852 + WORD $0xe123f017; WORD $0xb8a8d9bb // .quad -5140619573684080617 + WORD $0x157491e5; WORD $0xa60dc059 // .quad -6481312799871692315 + WORD $0xd96cec1d; WORD $0xe6d3102a // .quad -1814088448677712867 + WORD $0xad68db2f; WORD $0x87c89837 // .quad -8662506518347195601 + WORD $0xc7e41392; WORD $0x9043ea1a // .quad -8051334308064652398 + WORD $0x98c311fb; WORD $0x29babe45 // .quad 3006924907348169211 + WORD $0x79dd1877; WORD $0xb454e4a1 // .quad -5452481866653427593 + WORD $0xfef3d67a; WORD $0xf4296dd6 // .quad -853029884242176390 + WORD $0xd8545e94; WORD $0xe16a1dc9 // .quad -2203916314889396588 + WORD $0x5f58660c; WORD $0x1899e4a6 // .quad 1772699331562333708 + WORD $0x2734bb1d; WORD $0x8ce2529e // .quad -8294976724446954723 + WORD $0xf72e7f8f; WORD $0x5ec05dcf // .quad 6827560182880305039 + WORD $0xb101e9e4; WORD $0xb01ae745 // .quad -5757034887131305500 + WORD $0xf4fa1f73; WORD $0x76707543 // .quad 8534450228600381299 + WORD $0x1d42645d; WORD $0xdc21a117 // .quad -2584607590486743971 + WORD $0x791c53a8; WORD $0x6a06494a // .quad 7639874402088932264 + WORD $0x72497eba; WORD $0x899504ae // .quad -8532908771695296838 + WORD $0x17636892; WORD $0x0487db9d // .quad 326470965756389522 + WORD $0x0edbde69; WORD $0xabfa45da // .quad -6054449946191733143 + WORD $0x5d3c42b6; WORD $0x45a9d284 // .quad 5019774725622874806 + WORD $0x9292d603; WORD $0xd6f8d750 // .quad -2956376414312278525 + WORD $0xba45a9b2; WORD $0x0b8a2392 // .quad 831516194300602802 + WORD $0x5b9bc5c2; WORD $0x865b8692 // .quad -8765264286586255934 + WORD $0x68d7141e; WORD $0x8e6cac77 // .quad -8183976793979022306 + WORD $0xf282b732; WORD $0xa7f26836 // .quad -6344894339805432014 + WORD $0x430cd926; WORD $0x3207d795 // .quad 3605087062808385830 + WORD $0xaf2364ff; WORD $0xd1ef0244 // .quad -3319431906329402113 + WORD $0x49e807b8; WORD $0x7f44e6bd // .quad 9170708441896323000 + WORD $0xed761f1f; WORD $0x8335616a // .quad -8992173969096958177 + WORD $0x9c6209a6; WORD $0x5f16206c // .quad 6851699533943015846 + WORD $0xa8d3a6e7; WORD $0xa402b9c5 // .quad -6628531442943809817 + WORD $0xc37a8c0f; WORD $0x36dba887 // .quad 3952938399001381903 + WORD $0x130890a1; WORD $0xcd036837 // .quad -3673978285252374367 + WORD $0xda2c9789; WORD $0xc2494954 // .quad -4446942528265218167 + WORD $0x6be55a64; WORD $0x80222122 // .quad -9213765455923815836 + WORD $0x10b7bd6c; WORD $0xf2db9baa // .quad -946992141904134804 + WORD $0x06deb0fd; WORD $0xa02aa96b // .quad -6905520801477381891 + WORD $0x94e5acc7; WORD $0x6f928294 // .quad 8039631859474607303 + WORD $0xc8965d3d; WORD $0xc83553c5 // .quad -4020214983419339459 + WORD $0xba1f17f9; WORD $0xcb772339 // .quad -3785518230938904583 + WORD $0x3abbf48c; WORD $0xfa42a8b7 // .quad -413582710846786420 + WORD $0x14536efb; WORD $0xff2a7604 // .quad -60105885123121413 + WORD $0x84b578d7; WORD $0x9c69a972 // .quad -7176018221920323369 + WORD $0x19684aba; WORD $0xfef51385 // .quad -75132356403901766 + WORD $0x25e2d70d; WORD $0xc38413cf // .quad -4358336758973016307 + WORD $0x5fc25d69; WORD $0x7eb25866 // .quad 9129456591349898601 + WORD $0xef5b8cd1; WORD $0xf46518c2 // .quad -836234930288882479 + WORD $0xfbd97a61; WORD $0xef2f773f // .quad -1211618658047395231 + WORD $0xd5993802; WORD $0x98bf2f79 // .quad -7440175859071633406 + WORD $0xfacfd8fa; WORD $0xaafb550f // .quad -6126209340986631942 + WORD $0x4aff8603; WORD $0xbeeefb58 // .quad -4688533805412153853 + WORD $0xf983cf38; WORD $0x95ba2a53 // .quad -7657761676233289928 + WORD $0x5dbf6784; WORD $0xeeaaba2e // .quad -1248981238337804412 + WORD $0x7bf26183; WORD $0xdd945a74 // .quad -2480258038432112253 + WORD $0xfa97a0b2; WORD $0x952ab45c // .quad -7698142301602209614 + WORD $0x9aeef9e4; WORD $0x94f97111 // .quad -7712008566467528220 + WORD $0x393d88df; WORD $0xba756174 // .quad -5010991858575374113 + WORD $0x01aab85d; WORD $0x7a37cd56 // .quad 8806733365625141341 + WORD $0x478ceb17; WORD $0xe912b9d1 // .quad -1652053804791829737 + WORD $0xc10ab33a; WORD $0xac62e055 // .quad -6025006692552756422 + WORD $0xccb812ee; WORD $0x91abb422 // .quad -7950062655635975442 + WORD $0x314d6009; WORD $0x577b986b // .quad 6303799689591218185 + WORD $0x7fe617aa; WORD $0xb616a12b // .quad -5325892301117581398 + WORD $0xfda0b80b; WORD $0xed5a7e85 // .quad -1343622424865753077 + WORD $0x5fdf9d94; WORD $0xe39c4976 // .quad -2045679357969588844 + WORD $0xbe847307; WORD $0x14588f13 // .quad 1466078993672598279 + WORD $0xfbebc27d; WORD $0x8e41ade9 // .quad -8196078626372074883 + WORD $0xae258fc8; WORD $0x596eb2d8 // .quad 6444284760518135752 + WORD $0x7ae6b31c; WORD $0xb1d21964 // .quad -5633412264537705700 + WORD $0xd9aef3bb; WORD $0x6fca5f8e // .quad 8055355950647669691 + WORD $0x99a05fe3; WORD $0xde469fbd // .quad -2430079312244744221 + WORD $0x480d5854; WORD $0x25de7bb9 // .quad 2728754459941099604 + WORD $0x80043bee; WORD $0x8aec23d6 // .quad -8436328597794046994 + WORD $0x9a10ae6a; WORD $0xaf561aa7 // .quad -5812428961928401302 + WORD $0x20054ae9; WORD $0xada72ccc // .quad -5933724728815170839 + WORD $0x8094da04; WORD $0x1b2ba151 // .quad 1957835834444274180 + WORD $0x28069da4; WORD $0xd910f7ff // .quad -2805469892591575644 + WORD $0xf05d0842; WORD $0x90fb44d2 // .quad -7999724640327104446 + WORD $0x79042286; WORD $0x87aa9aff // .quad -8670947710510816634 + WORD $0xac744a53; WORD $0x353a1607 // .quad 3835402254873283155 + WORD $0x57452b28; WORD $0xa99541bf // .quad -6226998619711132888 + WORD $0x97915ce8; WORD $0x42889b89 // .quad 4794252818591603944 + WORD $0x2d1675f2; WORD $0xd3fa922f // .quad -3172062256211528206 + WORD $0xfebada11; WORD $0x69956135 // .quad 7608094030047140369 + WORD $0x7c2e09b7; WORD $0x847c9b5d // .quad -8900067937773286985 + WORD $0x7e699095; WORD $0x43fab983 // .quad 4898431519131537557 + WORD $0xdb398c25; WORD $0xa59bc234 // .quad -6513398903789220827 + WORD $0x5e03f4bb; WORD $0x94f967e4 // .quad -7712018656367741765 + WORD $0x1207ef2e; WORD $0xcf02b2c2 // .quad -3530062611309138130 + WORD $0xbac278f5; WORD $0x1d1be0ee // .quad 2097517367411243253 + WORD $0x4b44f57d; WORD $0x8161afb9 // .quad -9123818159709293187 + WORD $0x69731732; WORD $0x6462d92a // .quad 7233582727691441970 + WORD $0x9e1632dc; WORD $0xa1ba1ba7 // .quad -6793086681209228580 + WORD $0x03cfdcfe; WORD $0x7d7b8f75 // .quad 9041978409614302462 + WORD $0x859bbf93; WORD $0xca28a291 // .quad -3879672333084147821 + WORD $0x44c3d43e; WORD $0x5cda7352 // .quad 6690786993590490174 + WORD $0xe702af78; WORD $0xfcb2cb35 // .quad -237904397927796872 + WORD $0x6afa64a7; WORD $0x3a088813 // .quad 4181741870994056359 + WORD $0xb061adab; WORD $0x9defbf01 // .quad -7066219276345954901 + WORD $0x45b8fdd0; WORD $0x088aaa18 // .quad 615491320315182544 + WORD $0x1c7a1916; WORD $0xc56baec2 // .quad -4221088077005055722 + WORD $0x57273d45; WORD $0x8aad549e // .quad -8454007886460797627 + WORD $0xa3989f5b; WORD $0xf6c69a72 // .quad -664674077828931749 + WORD $0xf678864b; WORD $0x36ac54e2 // .quad 3939617107816777291 + WORD $0xa63f6399; WORD $0x9a3c2087 // .quad -7332950326284164199 + WORD $0xb416a7dd; WORD $0x84576a1b // .quad -8910536670511192099 + WORD $0x8fcf3c7f; WORD $0xc0cb28a9 // .quad -4554501889427817345 + WORD $0xa11c51d5; WORD $0x656d44a2 // .quad 7308573235570561493 + WORD $0xf3c30b9f; WORD $0xf0fdf2d3 // .quad -1081441343357383777 + WORD $0xa4b1b325; WORD $0x9f644ae5 // .quad -6961356773836868827 + WORD $0x7859e743; WORD $0x969eb7c4 // .quad -7593429867239446717 + WORD $0x0dde1fee; WORD $0x873d5d9f // .quad -8701695967296086034 + WORD $0x96706114; WORD $0xbc4665b5 // .quad -4880101315621920492 + WORD $0xd155a7ea; WORD $0xa90cb506 // .quad -6265433940692719638 + WORD $0xfc0c7959; WORD $0xeb57ff22 // .quad -1488440626100012711 + WORD $0x42d588f2; WORD $0x09a7f124 // .quad 695789805494438130 + WORD $0xdd87cbd8; WORD $0x9316ff75 // .quad -7847804418953589800 + WORD $0x538aeb2f; WORD $0x0c11ed6d // .quad 869737256868047663 + WORD $0x54e9bece; WORD $0xb7dcbf53 // .quad -5198069505264599346 + WORD $0xa86da5fa; WORD $0x8f1668c8 // .quad -8136200465769716230 + WORD $0x2a242e81; WORD $0xe5d3ef28 // .quad -1885900863153361279 + WORD $0x694487bc; WORD $0xf96e017d // .quad -473439272678684740 + WORD $0x1a569d10; WORD $0x8fa47579 // .quad -8096217067111932656 + WORD $0xc395a9ac; WORD $0x37c981dc // .quad 4019886927579031980 + WORD $0x60ec4455; WORD $0xb38d92d7 // .quad -5508585315462527915 + WORD $0xf47b1417; WORD $0x85bbe253 // .quad -8810199395808373737 + WORD $0x3927556a; WORD $0xe070f78d // .quad -2274045625900771990 + WORD $0x78ccec8e; WORD $0x93956d74 // .quad -7812217631593927538 + WORD $0x43b89562; WORD $0x8c469ab8 // .quad -8338807543829064350 + WORD $0x970027b2; WORD $0x387ac8d1 // .quad 4069786015789754290 + WORD $0x54a6babb; WORD $0xaf584166 // .quad -5811823411358942533 + WORD $0xfcc0319e; WORD $0x06997b05 // .quad 475546501309804958 + WORD $0xe9d0696a; WORD $0xdb2e51bf // .quad -2653093245771290262 + WORD $0xbdf81f03; WORD $0x441fece3 // .quad 4908902581746016003 + WORD $0xf22241e2; WORD $0x88fcf317 // .quad -8575712306248138270 + WORD $0xad7626c3; WORD $0xd527e81c // .quad -3087243809672255805 + WORD $0xeeaad25a; WORD $0xab3c2fdd // .quad -6107954364382784934 + WORD $0xd8d3b074; WORD $0x8a71e223 // .quad -8470740780517707660 + WORD $0x6a5586f1; WORD $0xd60b3bd5 // .quad -3023256937051093263 + WORD $0x67844e49; WORD $0xf6872d56 // .quad -682526969396179383 + WORD $0x62757456; WORD $0x85c70565 // .quad -8807064613298015146 + WORD $0x016561db; WORD $0xb428f8ac // .quad -5464844730172612133 + WORD $0xbb12d16c; WORD $0xa738c6be // .quad -6397144748195131028 + WORD $0x01beba52; WORD $0xe13336d7 // .quad -2219369894288377262 + WORD $0x69d785c7; WORD $0xd106f86e // .quad -3384744916816525881 + WORD $0x61173473; WORD $0xecc00246 // .quad -1387106183930235789 + WORD $0x0226b39c; WORD $0x82a45b45 // .quad -9032994600651410532 + WORD $0xf95d0190; WORD $0x27f002d7 // .quad 2877803288514593168 + WORD $0x42b06084; WORD $0xa34d7216 // .quad -6679557232386875260 + WORD $0xf7b441f4; WORD $0x31ec038d // .quad 3597254110643241460 + WORD $0xd35c78a5; WORD $0xcc20ce9b // .quad -3737760522056206171 + WORD $0x75a15271; WORD $0x7e670471 // .quad 9108253656731439729 + WORD $0xc83396ce; WORD $0xff290242 // .quad -60514634142869810 + WORD $0xe984d386; WORD $0x0f0062c6 // .quad 1080972517029761926 + WORD $0xbd203e41; WORD $0x9f79a169 // .quad -6955350673980375487 + WORD $0xa3e60868; WORD $0x52c07b78 // .quad 5962901664714590312 + WORD $0x2c684dd1; WORD $0xc75809c4 // .quad -4082502324048081455 + WORD $0xccdf8a82; WORD $0xa7709a56 // .quad -6381430974388925822 + WORD $0x37826145; WORD $0xf92e0c35 // .quad -491441886632713915 + WORD $0x400bb691; WORD $0x88a66076 // .quad -8600080377420466543 + WORD $0x42b17ccb; WORD $0x9bbcc7a1 // .quad -7224680206786528053 + WORD $0xd00ea435; WORD $0x6acff893 // .quad 7696643601933968437 + WORD $0x935ddbfe; WORD $0xc2abf989 // .quad -4419164240055772162 + WORD $0xc4124d43; WORD $0x0583f6b8 // .quad 397432465562684739 + WORD $0xf83552fe; WORD $0xf356f7eb // .quad -912269281642327298 + WORD $0x7a8b704a; WORD $0xc3727a33 // .quad -4363290727450709942 + WORD $0x7b2153de; WORD $0x98165af3 // .quad -7487697328667536418 + WORD $0x592e4c5c; WORD $0x744f18c0 // .quad 8380944645968776284 + WORD $0x59e9a8d6; WORD $0xbe1bf1b0 // .quad -4747935642407032618 + WORD $0x6f79df73; WORD $0x1162def0 // .quad 1252808770606194547 + WORD $0x7064130c; WORD $0xeda2ee1c // .quad -1323233534581402868 + WORD $0x45ac2ba8; WORD $0x8addcb56 // .quad -8440366555225904216 + WORD $0xc63e8be7; WORD $0x9485d4d1 // .quad -7744549986754458649 + WORD $0xd7173692; WORD $0x6d953e2b // .quad 7896285879677171346 + WORD $0x37ce2ee1; WORD $0xb9a74a06 // .quad -5069001465015685407 + WORD $0xccdd0437; WORD $0xc8fa8db6 // .quad -3964700705685699529 + WORD $0xc5c1ba99; WORD $0xe8111c87 // .quad -1724565812842218855 + WORD $0x400a22a2; WORD $0x1d9c9892 // .quad 2133748077373825698 + WORD $0xdb9914a0; WORD $0x910ab1d4 // .quad -7995382660667468640 + WORD $0xd00cab4b; WORD $0x2503beb6 // .quad 2667185096717282123 + WORD $0x127f59c8; WORD $0xb54d5e4a // .quad -5382542307406947896 + WORD $0x840fd61d; WORD $0x2e44ae64 // .quad 3333981370896602653 + WORD $0x971f303a; WORD $0xe2a0b5dc // .quad -2116491865831296966 + WORD $0xd289e5d2; WORD $0x5ceaecfe // .quad 6695424375237764562 + WORD $0xde737e24; WORD $0x8da471a9 // .quad -8240336443785642460 + WORD $0x872c5f47; WORD $0x7425a83e // .quad 8369280469047205703 + WORD $0x56105dad; WORD $0xb10d8e14 // .quad -5688734536304665171 + WORD $0x28f77719; WORD $0xd12f124e // .quad -3373457468973156583 + WORD $0x6b947518; WORD $0xdd50f199 // .quad -2499232151953443560 + WORD $0xd99aaa6f; WORD $0x82bd6b70 // .quad -9025939945749304721 + WORD $0xe33cc92f; WORD $0x8a5296ff // .quad -8479549122611984081 + WORD $0x1001550b; WORD $0x636cc64d // .quad 7164319141522920715 + WORD $0xdc0bfb7b; WORD $0xace73cbf // .quad -5987750384837592197 + WORD $0x5401aa4e; WORD $0x3c47f7e0 // .quad 4343712908476262990 + WORD $0xd30efa5a; WORD $0xd8210bef // .quad -2873001962619602342 + WORD $0x34810a71; WORD $0x65acfaec // .quad 7326506586225052273 + WORD $0xe3e95c78; WORD $0x8714a775 // .quad -8713155254278333320 + WORD $0x41a14d0d; WORD $0x7f1839a7 // .quad 9158133232781315341 + WORD $0x5ce3b396; WORD $0xa8d9d153 // .quad -6279758049420528746 + WORD $0x1209a050; WORD $0x1ede4811 // .quad 2224294504121868368 + WORD $0x341ca07c; WORD $0xd31045a8 // .quad -3238011543348273028 + WORD $0xab460432; WORD $0x934aed0a // .quad -7833187971778608078 + WORD $0x2091e44d; WORD $0x83ea2b89 // .quad -8941286242233752499 + WORD $0x5617853f; WORD $0xf81da84d // .quad -568112927868484289 + WORD $0x68b65d60; WORD $0xa4e4b66b // .quad -6564921784364802720 + WORD $0xab9d668e; WORD $0x36251260 // .quad 3901544858591782542 + WORD $0x42e3f4b9; WORD $0xce1de406 // .quad -3594466212028615495 + WORD $0x6b426019; WORD $0xc1d72b7c // .quad -4479063491021217767 + WORD $0xe9ce78f3; WORD $0x80d2ae83 // .quad -9164070410158966541 + WORD $0x8612f81f; WORD $0xb24cf65b // .quad -5598829363776522209 + WORD $0xe4421730; WORD $0xa1075a24 // .quad -6843401994271320272 + WORD $0x6797b627; WORD $0xdee033f2 // .quad -2386850686293264857 + WORD $0x1d529cfc; WORD $0xc94930ae // .quad -3942566474411762436 + WORD $0x017da3b1; WORD $0x169840ef // .quad 1628122660560806833 + WORD $0xa4a7443c; WORD $0xfb9b7cd9 // .quad -316522074587315140 + WORD $0x60ee864e; WORD $0x8e1f2895 // .quad -8205795374004271538 + WORD $0x06e88aa5; WORD $0x9d412e08 // .quad -7115355324258153819 + WORD $0xb92a27e2; WORD $0xf1a6f2ba // .quad -1033872180650563614 + WORD $0x08a2ad4e; WORD $0xc491798a // .quad -4282508136895304370 + WORD $0x6774b1db; WORD $0xae10af69 // .quad -5904026244240592421 + WORD $0x8acb58a2; WORD $0xf5b5d7ec // .quad -741449152691742558 + WORD $0xe0a8ef29; WORD $0xacca6da1 // .quad -5995859411864064215 + WORD $0xd6bf1765; WORD $0x9991a6f3 // .quad -7380934748073420955 + WORD $0x58d32af3; WORD $0x17fd090a // .quad 1728547772024695539 + WORD $0xcc6edd3f; WORD $0xbff610b0 // .quad -4614482416664388289 + WORD $0xef07f5b0; WORD $0xddfc4b4c // .quad -2451001303396518480 + WORD $0xff8a948e; WORD $0xeff394dc // .quad -1156417002403097458 + WORD $0x1564f98e; WORD $0x4abdaf10 // .quad 5385653213018257806 + WORD $0x1fb69cd9; WORD $0x95f83d0a // .quad -7640289654143017767 + WORD $0x1abe37f1; WORD $0x9d6d1ad4 // .quad -7102991539009341455 + WORD $0xa7a4440f; WORD $0xbb764c4c // .quad -4938676049251384305 + WORD $0x216dc5ed; WORD $0x84c86189 // .quad -8878739423761676819 + WORD $0xd18d5513; WORD $0xea53df5f // .quad -1561659043136842477 + WORD $0xb4e49bb4; WORD $0x32fd3cf5 // .quad 3674159897003727796 + WORD $0xe2f8552c; WORD $0x92746b9b // .quad -7893565929601608404 + WORD $0x221dc2a1; WORD $0x3fbc8c33 // .quad 4592699871254659745 + WORD $0xdbb66a77; WORD $0xb7118682 // .quad -5255271393574622601 + WORD $0xeaa5334a; WORD $0x0fabaf3f // .quad 1129188820640936778 + WORD $0x92a40515; WORD $0xe4d5e823 // .quad -1957403223540890347 + WORD $0xf2a7400e; WORD $0x29cb4d87 // .quad 3011586022114279438 + WORD $0x3ba6832d; WORD $0x8f05b116 // .quad -8140906042354138323 + WORD $0xef511012; WORD $0x743e20e9 // .quad 8376168546070237202 + WORD $0xca9023f8; WORD $0xb2c71d5b // .quad -5564446534515285000 + WORD $0x6b255416; WORD $0x914da924 // .quad -7976533391121755114 + WORD $0xbd342cf6; WORD $0xdf78e4b2 // .quad -2343872149716718346 + WORD $0xc2f7548e; WORD $0x1ad089b6 // .quad 1932195658189984910 + WORD $0xb6409c1a; WORD $0x8bab8eef // .quad -8382449121214030822 + WORD $0x73b529b1; WORD $0xa184ac24 // .quad -6808127464117294671 + WORD $0xa3d0c320; WORD $0xae9672ab // .quad -5866375383090150624 + WORD $0x90a2741e; WORD $0xc9e5d72d // .quad -3898473311719230434 + WORD $0x8cc4f3e8; WORD $0xda3c0f56 // .quad -2721283210435300376 + WORD $0x7a658892; WORD $0x7e2fa67c // .quad 9092669226243950738 + WORD $0x17fb1871; WORD $0x88658996 // .quad -8618331034163144591 + WORD $0x98feeab7; WORD $0xddbb901b // .quad -2469221522477225289 + WORD $0x9df9de8d; WORD $0xaa7eebfb // .quad -6161227774276542835 + WORD $0x7f3ea565; WORD $0x552a7422 // .quad 6136845133758244197 + WORD $0x85785631; WORD $0xd51ea6fa // .quad -3089848699418290639 + WORD $0x8f87275f; WORD $0xd53a8895 // .quad -3082000819042179233 + WORD $0x936b35de; WORD $0x8533285c // .quad -8848684464777513506 + WORD $0xf368f137; WORD $0x8a892aba // .quad -8464187042230111945 + WORD $0xb8460356; WORD $0xa67ff273 // .quad -6449169562544503978 + WORD $0xb0432d85; WORD $0x2d2b7569 // .quad 3254824252494523781 + WORD $0xa657842c; WORD $0xd01fef10 // .quad -3449775934753242068 + WORD $0x0e29fc73; WORD $0x9c3b2962 // .quad -7189106879045698445 + WORD $0x67f6b29b; WORD $0x8213f56a // .quad -9073638986861858149 + WORD $0x91b47b8f; WORD $0x8349f3ba // .quad -8986383598807123057 + WORD $0x01f45f42; WORD $0xa298f2c5 // .quad -6730362715149934782 + WORD $0x36219a73; WORD $0x241c70a9 // .quad 2602078556773259891 + WORD $0x42717713; WORD $0xcb3f2f76 // .quad -3801267375510030573 + WORD $0x83aa0110; WORD $0xed238cd3 // .quad -1359087822460813040 + WORD $0xd30dd4d7; WORD $0xfe0efb53 // .quad -139898200960150313 + WORD $0x324a40aa; WORD $0xf4363804 // .quad -849429889038008150 + WORD $0x63e8a506; WORD $0x9ec95d14 // .quad -7004965403241175802 + WORD $0x3edcd0d5; WORD $0xb143c605 // .quad -5673473379724898091 + WORD $0x7ce2ce48; WORD $0xc67bb459 // .quad -4144520735624081848 + WORD $0x8e94050a; WORD $0xdd94b786 // .quad -2480155706228734710 + WORD $0xdc1b81da; WORD $0xf81aa16f // .quad -568964901102714406 + WORD $0x191c8326; WORD $0xca7cf2b4 // .quad -3855940325606653146 + WORD $0xe9913128; WORD $0x9b10a4e5 // .quad -7273132090830278360 + WORD $0x1f63a3f0; WORD $0xfd1c2f61 // .quad -208239388580928528 + WORD $0x63f57d72; WORD $0xc1d4ce1f // .quad -4479729095110460046 + WORD $0x673c8cec; WORD $0xbc633b39 // .quad -4871985254153548564 + WORD $0x3cf2dccf; WORD $0xf24a01a7 // .quad -987975350460687153 + WORD $0xe085d813; WORD $0xd5be0503 // .quad -3044990783845967853 + WORD $0x8617ca01; WORD $0x976e4108 // .quad -7535013621679011327 + WORD $0xd8a74e18; WORD $0x4b2d8644 // .quad 5417133557047315992 + WORD $0xa79dbc82; WORD $0xbd49d14a // .quad -4807081008671376254 + WORD $0x0ed1219e; WORD $0xddf8e7d6 // .quad -2451955090545630818 + WORD $0x51852ba2; WORD $0xec9c459d // .quad -1397165242411832414 + WORD $0xc942b503; WORD $0xcabb90e5 // .quad -3838314940804713213 + WORD $0x52f33b45; WORD $0x93e1ab82 // .quad -7790757304148477115 + WORD $0x3b936243; WORD $0x3d6a751f // .quad 4425478360848884291 + WORD $0xe7b00a17; WORD $0xb8da1662 // .quad -5126760611758208489 + WORD $0x0a783ad4; WORD $0x0cc51267 // .quad 920161932633717460 + WORD $0xa19c0c9d; WORD $0xe7109bfb // .quad -1796764746270372707 + WORD $0x668b24c5; WORD $0x27fb2b80 // .quad 2880944217109767365 + WORD $0x450187e2; WORD $0x906a617d // .quad -8040506994060064798 + WORD $0x802dedf6; WORD $0xb1f9f660 // .quad -5622191765467566602 + WORD $0x9641e9da; WORD $0xb484f9dc // .quad -5438947724147693094 + WORD $0xa0396973; WORD $0x5e7873f8 // .quad 6807318348447705459 + WORD $0xbbd26451; WORD $0xe1a63853 // .quad -2186998636757228463 + WORD $0x6423e1e8; WORD $0xdb0b487b // .quad -2662955059861265944 + WORD $0x55637eb2; WORD $0x8d07e334 // .quad -8284403175614349646 + WORD $0x3d2cda62; WORD $0x91ce1a9a // .quad -7940379843253970334 + WORD $0x6abc5e5f; WORD $0xb049dc01 // .quad -5743817951090549153 + WORD $0xcc7810fb; WORD $0x7641a140 // .quad 8521269269642088699 + WORD $0xc56b75f7; WORD $0xdc5c5301 // .quad -2568086420435798537 + WORD $0x7fcb0a9d; WORD $0xa9e904c8 // .quad -6203421752542164323 + WORD $0x1b6329ba; WORD $0x89b9b3e1 // .quad -8522583040413455942 + WORD $0x9fbdcd44; WORD $0x546345fa // .quad 6080780864604458308 + WORD $0x623bf429; WORD $0xac2820d9 // .quad -6041542782089432023 + WORD $0x47ad4095; WORD $0xa97c1779 // .quad -6234081974526590827 + WORD $0xbacaf133; WORD $0xd732290f // .quad -2940242459184402125 + WORD $0xcccc485d; WORD $0x49ed8eab // .quad 5327070802775656541 + WORD $0xd4bed6c0; WORD $0x867f59a9 // .quad -8755180564631333184 + WORD $0xbfff5a74; WORD $0x5c68f256 // .quad 6658838503469570676 + WORD $0x49ee8c70; WORD $0xa81f3014 // .quad -6332289687361778576 + WORD $0x6fff3111; WORD $0x73832eec // .quad 8323548129336963345 + WORD $0x5c6a2f8c; WORD $0xd226fc19 // .quad -3303676090774835316 + WORD $0xc5ff7eab; WORD $0xc831fd53 // .quad -4021154456019173717 + WORD $0xd9c25db7; WORD $0x83585d8f // .quad -8982326584375353929 + WORD $0xb77f5e55; WORD $0xba3e7ca8 // .quad -5026443070023967147 + WORD $0xd032f525; WORD $0xa42e74f3 // .quad -6616222212041804507 + WORD $0xe55f35eb; WORD $0x28ce1bd2 // .quad 2940318199324816875 + WORD $0xc43fb26f; WORD $0xcd3a1230 // .quad -3658591746624867729 + WORD $0xcf5b81b3; WORD $0x7980d163 // .quad 8755227902219092403 + WORD $0x7aa7cf85; WORD $0x80444b5e // .quad -9204148869281624187 + WORD $0xc332621f; WORD $0xd7e105bc // .quad -2891023177508298209 + WORD $0x1951c366; WORD $0xa0555e36 // .quad -6893500068174642330 + WORD $0xf3fefaa7; WORD $0x8dd9472b // .quad -8225464990312760665 + WORD $0x9fa63440; WORD $0xc86ab5c3 // .quad -4005189066790915008 + WORD $0xf0feb951; WORD $0xb14f98f6 // .quad -5670145219463562927 + WORD $0x878fc150; WORD $0xfa856334 // .quad -394800315061255856 + WORD $0x569f33d3; WORD $0x6ed1bf9a // .quad 7985374283903742931 + WORD $0xd4b9d8d2; WORD $0x9c935e00 // .quad -7164279224554366766 + WORD $0xec4700c8; WORD $0x0a862f80 // .quad 758345818024902856 + WORD $0x09e84f07; WORD $0xc3b83581 // .quad -4343663012265570553 + WORD $0x2758c0fa; WORD $0xcd27bb61 // .quad -3663753745896259334 + WORD $0x4c6262c8; WORD $0xf4a642e1 // .quad -817892746904575288 + WORD $0xb897789c; WORD $0x8038d51c // .quad -9207375118826243940 + WORD $0xcfbd7dbd; WORD $0x98e7e9cc // .quad -7428711994456441411 + WORD $0xe6bd56c3; WORD $0xe0470a63 // .quad -2285846861678029117 + WORD $0x03acdd2c; WORD $0xbf21e440 // .quad -4674203974643163860 + WORD $0xe06cac74; WORD $0x1858ccfc // .quad 1754377441329851508 + WORD $0x04981478; WORD $0xeeea5d50 // .quad -1231068949876566920 + WORD $0x0c43ebc8; WORD $0x0f37801e // .quad 1096485900831157192 + WORD $0x02df0ccb; WORD $0x95527a52 // .quad -7686947121313936181 + WORD $0x8f54e6ba; WORD $0xd3056025 // .quad -3241078642388441414 + WORD $0x8396cffd; WORD $0xbaa718e6 // .quad -4996997883215032323 + WORD $0xf32a2069; WORD $0x47c6b82e // .quad 5172023733869224041 + WORD $0x247c83fd; WORD $0xe950df20 // .quad -1634561335591402499 + WORD $0x57fa5441; WORD $0x4cdc331d // .quad 5538357842881958977 + WORD $0x16cdd27e; WORD $0x91d28b74 // .quad -7939129862385708418 + WORD $0xadf8e952; WORD $0xe0133fe4 // .quad -2300424733252327086 + WORD $0x1c81471d; WORD $0xb6472e51 // .quad -5312226309554747619 + WORD $0xd97723a6; WORD $0x58180fdd // .quad 6347841120289366950 + WORD $0x63a198e5; WORD $0xe3d8f9e5 // .quad -2028596868516046619 + WORD $0xa7ea7648; WORD $0x570f09ea // .quad 6273243709394548296 + WORD $0x5e44ff8f; WORD $0x8e679c2f // .quad -8185402070463610993 + WORD $0x51e513da; WORD $0x2cd2cc65 // .quad 3229868618315797466 + WORD $0x35d63f73; WORD $0xb201833b // .quad -5620066569652125837 + WORD $0xa65e58d1; WORD $0xf8077f7e // .quad -574350245532641071 + WORD $0x034bcf4f; WORD $0xde81e40a // .quad -2413397193637769393 + WORD $0x27faf782; WORD $0xfb04afaf // .quad -358968903457900670 + WORD $0x420f6191; WORD $0x8b112e86 // .quad -8425902273664687727 + WORD $0xf1f9b563; WORD $0x79c5db9a // .quad 8774660907532399971 + WORD $0xd29339f6; WORD $0xadd57a27 // .quad -5920691823653471754 + WORD $0xae7822bc; WORD $0x18375281 // .quad 1744954097560724156 + WORD $0xc7380874; WORD $0xd94ad8b1 // .quad -2789178761139451788 + WORD $0x0d0b15b5; WORD $0x8f229391 // .quad -8132775725879323211 + WORD $0x1c830548; WORD $0x87cec76f // .quad -8660765753353239224 + WORD $0x504ddb22; WORD $0xb2eb3875 // .quad -5554283638921766110 + WORD $0xe3a3c69a; WORD $0xa9c2794a // .quad -6214271173264161126 + WORD $0xa46151eb; WORD $0x5fa60692 // .quad 6892203506629956075 + WORD $0x9c8cb841; WORD $0xd433179d // .quad -3156152948152813503 + WORD $0xa6bcd333; WORD $0xdbc7c41b // .quad -2609901835997359309 + WORD $0x81d7f328; WORD $0x849feec2 // .quad -8890124620236590296 + WORD $0x906c0800; WORD $0x12b9b522 // .quad 1349308723430688768 + WORD $0x224deff3; WORD $0xa5c7ea73 // .quad -6500969756868349965 + WORD $0x34870a00; WORD $0xd768226b // .quad -2925050114139026944 + WORD $0xeae16bef; WORD $0xcf39e50f // .quad -3514526177658049553 + WORD $0x00d46640; WORD $0xe6a11583 // .quad -1828156321336891840 + WORD $0xf2cce375; WORD $0x81842f29 // .quad -9114107888677362827 + WORD $0xc1097fd0; WORD $0x60495ae3 // .quad 6938176635183661008 + WORD $0x6f801c53; WORD $0xa1e53af4 // .quad -6780948842419315629 + WORD $0xb14bdfc4; WORD $0x385bb19c // .quad 4061034775552188356 + WORD $0x8b602368; WORD $0xca5e89b1 // .quad -3864500034596756632 + WORD $0xdd9ed7b5; WORD $0x46729e03 // .quad 5076293469440235445 + WORD $0xee382c42; WORD $0xfcf62c1d // .quad -218939024818557886 + WORD $0x6a8346d1; WORD $0x6c07a2c2 // .quad 7784369436827535057 + WORD $0xb4e31ba9; WORD $0x9e19db92 // .quad -7054365918152680535 + WORD $0x05241885; WORD $0xc7098b73 // .quad -4104596259247744891 + WORD $0x621be293; WORD $0xc5a05277 // .quad -4206271379263462765 + WORD $0xc66d1ea7; WORD $0xb8cbee4f // .quad -5130745324059681113 + WORD $0x3aa2db38; WORD $0xf7086715 // .quad -646153205651940552 + WORD $0xdc043328; WORD $0x737f74f1 // .quad 8322499218531169064 + WORD $0x44a5c903; WORD $0x9a65406d // .quad -7321374781173544701 + WORD $0x53053ff2; WORD $0x505f522e // .quad 5791438004736573426 + WORD $0x95cf3b44; WORD $0xc0fe9088 // .quad -4540032458039542972 + WORD $0xe7c68fef; WORD $0x647726b9 // .quad 7239297505920716783 + WORD $0xbb430a15; WORD $0xf13e34aa // .quad -1063354554122040811 + WORD $0x30dc19f5; WORD $0x5eca7834 // .quad 6830403950414141941 + WORD $0xb509e64d; WORD $0x96c6e0ea // .quad -7582125623967357363 + WORD $0x3d132072; WORD $0xb67d1641 // .quad -5297053117264486286 + WORD $0x624c5fe0; WORD $0xbc789925 // .quad -4865971011531808800 + WORD $0x8c57e88f; WORD $0xe41c5bd1 // .quad -2009630378153219953 + WORD $0xbadf77d8; WORD $0xeb96bf6e // .quad -1470777745987373096 + WORD $0xf7b6f159; WORD $0x8e91b962 // .quad -8173548013986844327 + WORD $0x34cbaae7; WORD $0x933e37a5 // .quad -7836765118883190041 + WORD $0xb5a4adb0; WORD $0x723627bb // .quad 8229809056225996208 + WORD $0x81fe95a1; WORD $0xb80dc58e // .quad -5184270380176599647 + WORD $0xa30dd91c; WORD $0xcec3b1aa // .quad -3547796734999668452 + WORD $0x227e3b09; WORD $0xe61136f2 // .quad -1868651956793361655 + WORD $0xa5e8a7b1; WORD $0x213a4f0a // .quad 2394313059052595121 + WORD $0x558ee4e6; WORD $0x8fcac257 // .quad -8085436500636932890 + WORD $0x4f62d19d; WORD $0xa988e2cd // .quad -6230480713039031907 + WORD $0x2af29e1f; WORD $0xb3bd72ed // .quad -5495109607368778209 + WORD $0xa33b8605; WORD $0x93eb1b80 // .quad -7788100891298789883 + WORD $0x75af45a7; WORD $0xe0accfa8 // .quad -2257200990783584857 + WORD $0x660533c3; WORD $0xbc72f130 // .quad -4867563057061743677 + WORD $0x498d8b88; WORD $0x8c6c01c9 // .quad -8328279646880822392 + WORD $0x7f8680b4; WORD $0xeb8fad7c // .quad -1472767802899791692 + WORD $0x9bf0ee6a; WORD $0xaf87023b // .quad -5798663540173640086 + WORD $0x9f6820e1; WORD $0xa67398db // .quad -6452645772052127519 + WORD $0x82ed2a05; WORD $0xdb68c2ca // .quad -2636643406789662203 + WORD $0x43a1148c; WORD $0x88083f89 // .quad -8644589625959967604 + WORD $0x91d43a43; WORD $0x892179be // .quad -8565431156884620733 + WORD $0x948959b0; WORD $0x6a0a4f6b // .quad 7641007041259592112 + WORD $0x364948d4; WORD $0xab69d82e // .quad -6095102927678388012 + WORD $0x79abb01c; WORD $0x848ce346 // .quad -8895485272135061476 + WORD $0xc3db9b09; WORD $0xd6444e39 // .quad -3007192641170597111 + WORD $0x0c0b4e11; WORD $0xf2d80e0c // .quad -947992276657025519 + WORD $0x1a6940e5; WORD $0x85eab0e4 // .quad -8797024428372705051 + WORD $0x0f0e2195; WORD $0x6f8e118f // .quad 8038381691033493909 + WORD $0x2103911f; WORD $0xa7655d1d // .quad -6384594517038493409 + WORD $0xd2d1a9fb; WORD $0x4b7195f2 // .quad 5436291095364479483 + WORD $0x69447567; WORD $0xd13eb464 // .quad -3369057127870728857 + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + // .p2align 2, 0x00 +_POW_TAB: + WORD $0x00000001 // .long 1 + WORD $0x00000003 // .long 3 + WORD $0x00000006 // .long 6 + WORD $0x00000009 // .long 9 + WORD $0x0000000d // .long 13 + WORD $0x00000010 // .long 16 + WORD $0x00000013 // .long 19 + WORD $0x00000017 // .long 23 + WORD $0x0000001a // .long 26 + // .p2align 2, 0x00 +_LSHIFT_TAB: + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .space 4, '\x00\x00\x00\x00' + WORD $0x00000001 // .long 1 + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000001 // .long 1 + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000001 // .long 1 + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000002 // .long 2 + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000002 // .long 2 + WORD $0x35323133 // .asciz 4, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000002 // .long 2 + WORD $0x32363531 // .asciz 4, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000003 // .long 3 + WORD $0x32313837 // .asciz 4, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000003 // .long 3 + WORD $0x36303933 // .asciz 4, '390625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000003 // .long 3 + WORD $0x33353931 // .asciz 4, '1953125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000004 // .long 4 + WORD $0x35363739 // .asciz 4, '9765625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000004 // .long 4 + WORD $0x32383834 // .asciz 4, '48828125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323138 // .asciz 4, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000004 // .long 4 + WORD $0x31343432 // .asciz 4, '244140625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363034 // .asciz 4, '40625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000004 // .long 4 + WORD $0x30323231 // .asciz 4, '1220703125\x00\x00\x00\x00\x00\x00' + WORD $0x31333037 // .asciz 4, '703125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000005 // .long 5 + WORD $0x33303136 // .asciz 4, '6103515625\x00\x00\x00\x00\x00\x00' + WORD $0x36353135 // .asciz 4, '515625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000005 // .long 5 + WORD $0x31353033 // .asciz 4, '30517578125\x00\x00\x00\x00\x00' + WORD $0x38373537 // .asciz 4, '7578125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000005 // .long 5 + WORD $0x35323531 // .asciz 4, '152587890625\x00\x00\x00\x00' + WORD $0x39383738 // .asciz 4, '87890625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323630 // .asciz 4, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000006 // .long 6 + WORD $0x39323637 // .asciz 4, '762939453125\x00\x00\x00\x00' + WORD $0x35343933 // .asciz 4, '39453125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323133 // .asciz 4, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000006 // .long 6 + WORD $0x34313833 // .asciz 4, '3814697265625\x00\x00\x00' + WORD $0x32373936 // .asciz 4, '697265625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363536 // .asciz 4, '65625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000006 // .long 6 + WORD $0x37303931 // .asciz 4, '19073486328125\x00\x00' + WORD $0x36383433 // .asciz 4, '3486328125\x00\x00\x00\x00\x00\x00' + WORD $0x31383233 // .asciz 4, '328125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000007 // .long 7 + WORD $0x36333539 // .asciz 4, '95367431640625\x00\x00' + WORD $0x31333437 // .asciz 4, '7431640625\x00\x00\x00\x00\x00\x00' + WORD $0x36303436 // .asciz 4, '640625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000007 // .long 7 + WORD $0x38363734 // .asciz 4, '476837158203125\x00' + WORD $0x35313733 // .asciz 4, '37158203125\x00\x00\x00\x00\x00' + WORD $0x33303238 // .asciz 4, '8203125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000007 // .long 7 + WORD $0x34383332 // .asciz 4, '2384185791015625' + WORD $0x37353831 // .asciz 4, '185791015625\x00\x00\x00\x00' + WORD $0x31303139 // .asciz 4, '91015625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323635 // .asciz 4, '5625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000007 // .long 7 + WORD $0x32393131 // .asciz 4, '1192092895507812' + WORD $0x38323930 // .asciz 4, '0928955078125\x00\x00\x00' + WORD $0x30353539 // .asciz 4, '955078125\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32313837 // .asciz 4, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000008 // .long 8 + WORD $0x30363935 // .asciz 4, '5960464477539062' + WORD $0x34343634 // .asciz 4, '4644775390625\x00\x00\x00' + WORD $0x33353737 // .asciz 4, '775390625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363039 // .asciz 4, '90625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000008 // .long 8 + WORD $0x30383932 // .asciz 4, '2980232238769531' + WORD $0x32323332 // .asciz 4, '23223876953125\x00\x00' + WORD $0x36373833 // .asciz 4, '3876953125\x00\x00\x00\x00\x00\x00' + WORD $0x31333539 // .asciz 4, '953125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000008 // .long 8 + WORD $0x30393431 // .asciz 4, '1490116119384765' + WORD $0x31363131 // .asciz 4, '116119384765625\x00' + WORD $0x38333931 // .asciz 4, '19384765625\x00\x00\x00\x00\x00' + WORD $0x35363734 // .asciz 4, '4765625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000009 // .long 9 + WORD $0x30353437 // .asciz 4, '7450580596923828' + WORD $0x35303835 // .asciz 4, '580596923828125\x00' + WORD $0x32393639 // .asciz 4, '96923828125\x00\x00\x00\x00\x00' + WORD $0x38323833 // .asciz 4, '3828125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000009 // .long 9 + WORD $0x35323733 // .asciz 4, '3725290298461914' + WORD $0x32303932 // .asciz 4, '2902984619140625' + WORD $0x36343839 // .asciz 4, '984619140625\x00\x00\x00\x00' + WORD $0x34313931 // .asciz 4, '19140625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323630 // .asciz 4, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000009 // .long 9 + WORD $0x32363831 // .asciz 4, '1862645149230957' + WORD $0x31353436 // .asciz 4, '6451492309570312' + WORD $0x33323934 // .asciz 4, '4923095703125\x00\x00\x00' + WORD $0x37353930 // .asciz 4, '095703125\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32313330 // .asciz 4, '03125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000a // .long 10 + WORD $0x33313339 // .asciz 4, '9313225746154785' + WORD $0x37353232 // .asciz 4, '2257461547851562' + WORD $0x35313634 // .asciz 4, '4615478515625\x00\x00\x00' + WORD $0x35383734 // .asciz 4, '478515625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363531 // .asciz 4, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000a // .long 10 + WORD $0x36353634 // .asciz 4, '4656612873077392' + WORD $0x38323136 // .asciz 4, '6128730773925781' + WORD $0x37303337 // .asciz 4, '73077392578125\x00\x00' + WORD $0x32393337 // .asciz 4, '7392578125\x00\x00\x00\x00\x00\x00' + WORD $0x31383735 // .asciz 4, '578125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000a // .long 10 + WORD $0x38323332 // .asciz 4, '2328306436538696' + WORD $0x34363033 // .asciz 4, '3064365386962890' + WORD $0x33353633 // .asciz 4, '365386962890625\x00' + WORD $0x36393638 // .asciz 4, '86962890625\x00\x00\x00\x00\x00' + WORD $0x30393832 // .asciz 4, '2890625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000a // .long 10 + WORD $0x34363131 // .asciz 4, '1164153218269348' + WORD $0x32333531 // .asciz 4, '1532182693481445' + WORD $0x36323831 // .asciz 4, '1826934814453125' + WORD $0x38343339 // .asciz 4, '934814453125\x00\x00\x00\x00' + WORD $0x35343431 // .asciz 4, '14453125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323133 // .asciz 4, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000b // .long 11 + WORD $0x30323835 // .asciz 4, '5820766091346740' + WORD $0x30363637 // .asciz 4, '7660913467407226' + WORD $0x34333139 // .asciz 4, '9134674072265625' + WORD $0x30343736 // .asciz 4, '674072265625\x00\x00\x00\x00' + WORD $0x36323237 // .asciz 4, '72265625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323635 // .asciz 4, '5625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000b // .long 11 + WORD $0x30313932 // .asciz 4, '2910383045673370' + WORD $0x30333833 // .asciz 4, '3830456733703613' + WORD $0x37363534 // .asciz 4, '4567337036132812' + WORD $0x30373333 // .asciz 4, '3370361328125\x00\x00\x00' + WORD $0x33313633 // .asciz 4, '361328125\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32313832 // .asciz 4, '28125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000b // .long 11 + WORD $0x35353431 // .asciz 4, '1455191522836685' + WORD $0x35313931 // .asciz 4, '1915228366851806' + WORD $0x33383232 // .asciz 4, '2283668518066406' + WORD $0x35383636 // .asciz 4, '66851806640625\x00\x00' + WORD $0x36303831 // .asciz 4, '1806640625\x00\x00\x00\x00\x00\x00' + WORD $0x36303436 // .asciz 4, '640625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000c // .long 12 + WORD $0x35373237 // .asciz 4, '7275957614183425' + WORD $0x36373539 // .asciz 4, '9576141834259033' + WORD $0x38313431 // .asciz 4, '1418342590332031' + WORD $0x35323433 // .asciz 4, '34259033203125\x00\x00' + WORD $0x33333039 // .asciz 4, '9033203125\x00\x00\x00\x00\x00\x00' + WORD $0x31333032 // .asciz 4, '203125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000c // .long 12 + WORD $0x37333633 // .asciz 4, '3637978807091712' + WORD $0x38383739 // .asciz 4, '9788070917129516' + WORD $0x39303730 // .asciz 4, '0709171295166015' + WORD $0x32313731 // .asciz 4, '171295166015625\x00' + WORD $0x36313539 // .asciz 4, '95166015625\x00\x00\x00\x00\x00' + WORD $0x35313036 // .asciz 4, '6015625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000c // .long 12 + WORD $0x38313831 // .asciz 4, '1818989403545856' + WORD $0x34393839 // .asciz 4, '9894035458564758' + WORD $0x34353330 // .asciz 4, '0354585647583007' + WORD $0x36353835 // .asciz 4, '5856475830078125' + WORD $0x38353734 // .asciz 4, '475830078125\x00\x00\x00\x00' + WORD $0x37303033 // .asciz 4, '30078125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323138 // .asciz 4, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000d // .long 13 + WORD $0x34393039 // .asciz 4, '9094947017729282' + WORD $0x30373439 // .asciz 4, '9470177292823791' + WORD $0x32373731 // .asciz 4, '1772928237915039' + WORD $0x32383239 // .asciz 4, '9282379150390625' + WORD $0x31393733 // .asciz 4, '379150390625\x00\x00\x00\x00' + WORD $0x39333035 // .asciz 4, '50390625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323630 // .asciz 4, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000d // .long 13 + WORD $0x37343534 // .asciz 4, '4547473508864641' + WORD $0x35333734 // .asciz 4, '4735088646411895' + WORD $0x36383830 // .asciz 4, '0886464118957519' + WORD $0x31343634 // .asciz 4, '4641189575195312' + WORD $0x35393831 // .asciz 4, '1895751953125\x00\x00\x00' + WORD $0x39313537 // .asciz 4, '751953125\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32313335 // .asciz 4, '53125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000d // .long 13 + WORD $0x33373232 // .asciz 4, '2273736754432320' + WORD $0x37363337 // .asciz 4, '7367544323205947' + WORD $0x33343435 // .asciz 4, '5443232059478759' + WORD $0x30323332 // .asciz 4, '2320594787597656' + WORD $0x37343935 // .asciz 4, '59478759765625\x00\x00' + WORD $0x39353738 // .asciz 4, '8759765625\x00\x00\x00\x00\x00\x00' + WORD $0x36353637 // .asciz 4, '765625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000d // .long 13 + WORD $0x36333131 // .asciz 4, '1136868377216160' + WORD $0x33383638 // .asciz 4, '8683772161602973' + WORD $0x31323737 // .asciz 4, '7721616029739379' + WORD $0x30363136 // .asciz 4, '6160297393798828' + WORD $0x33373932 // .asciz 4, '297393798828125\x00' + WORD $0x39373339 // .asciz 4, '93798828125\x00\x00\x00\x00\x00' + WORD $0x38323838 // .asciz 4, '8828125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000e // .long 14 + WORD $0x34383635 // .asciz 4, '5684341886080801' + WORD $0x38313433 // .asciz 4, '3418860808014869' + WORD $0x38303638 // .asciz 4, '8608080148696899' + WORD $0x31303830 // .asciz 4, '0801486968994140' + WORD $0x39363834 // .asciz 4, '486968994140625\x00' + WORD $0x39393836 // .asciz 4, '68994140625\x00\x00\x00\x00\x00' + WORD $0x30343134 // .asciz 4, '4140625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000e // .long 14 + WORD $0x32343832 // .asciz 4, '2842170943040400' + WORD $0x39303731 // .asciz 4, '1709430404007434' + WORD $0x34303334 // .asciz 4, '4304040074348449' + WORD $0x30303430 // .asciz 4, '0400743484497070' + WORD $0x34333437 // .asciz 4, '7434844970703125' + WORD $0x39343438 // .asciz 4, '844970703125\x00\x00\x00\x00' + WORD $0x30373037 // .asciz 4, '70703125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323133 // .asciz 4, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000e // .long 14 + WORD $0x31323431 // .asciz 4, '1421085471520200' + WORD $0x34353830 // .asciz 4, '0854715202003717' + WORD $0x32353137 // .asciz 4, '7152020037174224' + WORD $0x30303230 // .asciz 4, '0200371742248535' + WORD $0x37313733 // .asciz 4, '3717422485351562' + WORD $0x34323234 // .asciz 4, '4224853515625\x00\x00\x00' + WORD $0x35333538 // .asciz 4, '853515625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363531 // .asciz 4, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000f // .long 15 + WORD $0x35303137 // .asciz 4, '7105427357601001' + WORD $0x33373234 // .asciz 4, '4273576010018587' + WORD $0x30363735 // .asciz 4, '5760100185871124' + WORD $0x31303031 // .asciz 4, '1001858711242675' + WORD $0x37383538 // .asciz 4, '8587112426757812' + WORD $0x34323131 // .asciz 4, '1124267578125\x00\x00\x00' + WORD $0x35373632 // .asciz 4, '267578125\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32313837 // .asciz 4, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000f // .long 15 + WORD $0x32353533 // .asciz 4, '3552713678800500' + WORD $0x36333137 // .asciz 4, '7136788005009293' + WORD $0x30383837 // .asciz 4, '7880050092935562' + WORD $0x30303530 // .asciz 4, '0500929355621337' + WORD $0x33393239 // .asciz 4, '9293556213378906' + WORD $0x32363535 // .asciz 4, '55621337890625\x00\x00' + WORD $0x37333331 // .asciz 4, '1337890625\x00\x00\x00\x00\x00\x00' + WORD $0x36303938 // .asciz 4, '890625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x0000000f // .long 15 + WORD $0x36373731 // .asciz 4, '1776356839400250' + WORD $0x38363533 // .asciz 4, '3568394002504646' + WORD $0x30343933 // .asciz 4, '3940025046467781' + WORD $0x30353230 // .asciz 4, '0250464677810668' + WORD $0x36343634 // .asciz 4, '4646778106689453' + WORD $0x31383737 // .asciz 4, '778106689453125\x00' + WORD $0x38363630 // .asciz 4, '06689453125\x00\x00\x00\x00\x00' + WORD $0x33353439 // .asciz 4, '9453125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000010 // .long 16 + WORD $0x31383838 // .asciz 4, '8881784197001252' + WORD $0x31343837 // .asciz 4, '7841970012523233' + WORD $0x30303739 // .asciz 4, '9700125232338905' + WORD $0x32353231 // .asciz 4, '1252323389053344' + WORD $0x33333233 // .asciz 4, '3233890533447265' + WORD $0x35303938 // .asciz 4, '890533447265625\x00' + WORD $0x34343333 // .asciz 4, '33447265625\x00\x00\x00\x00\x00' + WORD $0x35363237 // .asciz 4, '7265625\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353236 // .asciz 4, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000010 // .long 16 + WORD $0x30343434 // .asciz 4, '4440892098500626' + WORD $0x30323938 // .asciz 4, '8920985006261616' + WORD $0x30353839 // .asciz 4, '9850062616169452' + WORD $0x36323630 // .asciz 4, '0626161694526672' + WORD $0x36313631 // .asciz 4, '1616945266723632' + WORD $0x32353439 // .asciz 4, '9452667236328125' + WORD $0x32373636 // .asciz 4, '667236328125\x00\x00\x00\x00' + WORD $0x32333633 // .asciz 4, '36328125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323138 // .asciz 4, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000010 // .long 16 + WORD $0x30323232 // .asciz 4, '2220446049250313' + WORD $0x30363434 // .asciz 4, '4460492503130808' + WORD $0x35323934 // .asciz 4, '4925031308084726' + WORD $0x33313330 // .asciz 4, '0313080847263336' + WORD $0x38303830 // .asciz 4, '0808472633361816' + WORD $0x36323734 // .asciz 4, '4726333618164062' + WORD $0x36333333 // .asciz 4, '3336181640625\x00\x00\x00' + WORD $0x36313831 // .asciz 4, '181640625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363034 // .asciz 4, '40625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000010 // .long 16 + WORD $0x30313131 // .asciz 4, '1110223024625156' + WORD $0x30333232 // .asciz 4, '2230246251565404' + WORD $0x32363432 // .asciz 4, '2462515654042363' + WORD $0x36353135 // .asciz 4, '5156540423631668' + WORD $0x34303435 // .asciz 4, '5404236316680908' + WORD $0x33363332 // .asciz 4, '2363166809082031' + WORD $0x38363631 // .asciz 4, '16680908203125\x00\x00' + WORD $0x38303930 // .asciz 4, '0908203125\x00\x00\x00\x00\x00\x00' + WORD $0x31333032 // .asciz 4, '203125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000011 // .long 17 + WORD $0x31353535 // .asciz 4, '5551115123125782' + WORD $0x31353131 // .asciz 4, '1151231257827021' + WORD $0x32313332 // .asciz 4, '2312578270211815' + WORD $0x32383735 // .asciz 4, '5782702118158340' + WORD $0x31323037 // .asciz 4, '7021181583404541' + WORD $0x35313831 // .asciz 4, '1815834045410156' + WORD $0x30343338 // .asciz 4, '83404541015625\x00\x00' + WORD $0x31343534 // .asciz 4, '4541015625\x00\x00\x00\x00\x00\x00' + WORD $0x36353130 // .asciz 4, '015625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000011 // .long 17 + WORD $0x35373732 // .asciz 4, '2775557561562891' + WORD $0x35373535 // .asciz 4, '5575615628913510' + WORD $0x36353136 // .asciz 4, '6156289135105907' + WORD $0x31393832 // .asciz 4, '2891351059079170' + WORD $0x30313533 // .asciz 4, '3510590791702270' + WORD $0x37303935 // .asciz 4, '5907917022705078' + WORD $0x30373139 // .asciz 4, '917022705078125\x00' + WORD $0x30373232 // .asciz 4, '22705078125\x00\x00\x00\x00\x00' + WORD $0x38373035 // .asciz 4, '5078125\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00353231 // .asciz 4, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000011 // .long 17 + WORD $0x37383331 // .asciz 4, '1387778780781445' + WORD $0x37383737 // .asciz 4, '7787807814456755' + WORD $0x38373038 // .asciz 4, '8078144567552953' + WORD $0x35343431 // .asciz 4, '1445675529539585' + WORD $0x35353736 // .asciz 4, '6755295395851135' + WORD $0x33353932 // .asciz 4, '2953958511352539' + WORD $0x35383539 // .asciz 4, '9585113525390625' + WORD $0x35333131 // .asciz 4, '113525390625\x00\x00\x00\x00' + WORD $0x39333532 // .asciz 4, '25390625\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323630 // .asciz 4, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000012 // .long 18 + WORD $0x38333936 // .asciz 4, '6938893903907228' + WORD $0x39333938 // .asciz 4, '8939039072283776' + WORD $0x30393330 // .asciz 4, '0390722837764769' + WORD $0x38323237 // .asciz 4, '7228377647697925' + WORD $0x36373733 // .asciz 4, '3776476979255676' + WORD $0x39363734 // .asciz 4, '4769792556762695' + WORD $0x35323937 // .asciz 4, '7925567626953125' + WORD $0x36373635 // .asciz 4, '567626953125\x00\x00\x00\x00' + WORD $0x35393632 // .asciz 4, '26953125\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x35323133 // .asciz 4, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000012 // .long 18 + WORD $0x39363433 // .asciz 4, '3469446951953614' + WORD $0x39363434 // .asciz 4, '4469519536141888' + WORD $0x35393135 // .asciz 4, '5195361418882384' + WORD $0x34313633 // .asciz 4, '3614188823848962' + WORD $0x38383831 // .asciz 4, '1888238489627838' + WORD $0x34383332 // .asciz 4, '2384896278381347' + WORD $0x32363938 // .asciz 4, '8962783813476562' + WORD $0x38333837 // .asciz 4, '7838134765625\x00\x00\x00' + WORD $0x37343331 // .asciz 4, '134765625\x00\x00\x00\x00\x00\x00\x00' + WORD $0x32363536 // .asciz 4, '65625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000035 // .asciz 4, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000012 // .long 18 + WORD $0x34333731 // .asciz 4, '1734723475976807' + WORD $0x34333237 // .asciz 4, '7234759768070944' + WORD $0x37393537 // .asciz 4, '7597680709441192' + WORD $0x37303836 // .asciz 4, '6807094411924481' + WORD $0x34343930 // .asciz 4, '0944119244813919' + WORD $0x32393131 // .asciz 4, '1192448139190673' + WORD $0x31383434 // .asciz 4, '4481391906738281' + WORD $0x39313933 // .asciz 4, '39190673828125\x00\x00' + WORD $0x33373630 // .asciz 4, '0673828125\x00\x00\x00\x00\x00\x00' + WORD $0x31383238 // .asciz 4, '828125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + WORD $0x00000013 // .long 19 + WORD $0x33373638 // .asciz 4, '8673617379884035' + WORD $0x33373136 // .asciz 4, '6173798840354720' + WORD $0x38383937 // .asciz 4, '7988403547205962' + WORD $0x35333034 // .asciz 4, '4035472059622406' + WORD $0x30323734 // .asciz 4, '4720596224069595' + WORD $0x32363935 // .asciz 4, '5962240695953369' + WORD $0x36303432 // .asciz 4, '2406959533691406' + WORD $0x35393539 // .asciz 4, '95953369140625\x00\x00' + WORD $0x39363333 // .asciz 4, '3369140625\x00\x00\x00\x00\x00\x00' + WORD $0x36303431 // .asciz 4, '140625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00003532 // .asciz 4, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00\x00\x00\x00\x00' + WORD $0x00000000 // .asciz 4, '\x00\x00\x00\x00' + +TEXT ·__vnumber(SB), $0-24 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $144, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_vnumber: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + MOVD v+16(FP), R2 + CALL ·__vnumber_arm64_entry__+24(SB) // _vnumber + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/vnumber_subr_arm64.go b/internal/native/neon/vnumber_subr_arm64.go new file mode 100644 index 000000000..2650c2f21 --- /dev/null +++ b/internal/native/neon/vnumber_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __vnumber_arm64_entry__() uintptr + +var ( + _subr__vnumber uintptr = __vnumber_arm64_entry__() + 12 +) + +const ( + _stack__vnumber = 112 +) + +var ( + _ = _subr__vnumber +) + +const ( + _ = _stack__vnumber +) diff --git a/internal/native/neon/vsigned_arm64.go b/internal/native/neon/vsigned_arm64.go new file mode 100644 index 000000000..35b4c6083 --- /dev/null +++ b/internal/native/neon/vsigned_arm64.go @@ -0,0 +1,32 @@ + +/* + * 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 neon + +import ( + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func vsigned(s *string, p *int, v *types.JsonState) { + __vsigned(s, p, v) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vsigned(s *string, p *int, v *types.JsonState) diff --git a/internal/native/neon/vsigned_arm64.s b/internal/native/neon/vsigned_arm64.s new file mode 100644 index 000000000..984ef1320 --- /dev/null +++ b/internal/native/neon/vsigned_arm64.s @@ -0,0 +1,149 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__vsigned_arm64_entry__(SB), NOSPLIT, $16 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_vsigned: + MOVD.W R30, -32(RSP) // WORD $0xf81e0ffe // str x30, [sp, #-32]! + WORD $0xf9400028 // ldr x8, [x1] + WORD $0xa940240a // ldp x10, x9, [x0] + WORD $0x5280012b // mov w11, #9 + WORD $0xa900fc5f // stp xzr, xzr, [x2, #8] + WORD $0xf900004b // str x11, [x2] + WORD $0xf940002b // ldr x11, [x1] + WORD $0xf9000c4b // str x11, [x2, #24] + WORD $0xeb09011f // cmp x8, x9 + WORD $0x540006c2 // b.hs LBB0_13 $216(%rip) + WORD $0x3868694c // ldrb w12, [x10, x8] + WORD $0x7100b59f // cmp w12, #45 + WORD $0x54000701 // b.ne LBB0_14 $224(%rip) + WORD $0x91000508 // add x8, x8, #1 + WORD $0xeb09011f // cmp x8, x9 + WORD $0x54000602 // b.hs LBB0_13 $192(%rip) + WORD $0x3868694c // ldrb w12, [x10, x8] + WORD $0x9280000b // mov x11, #-1 + WORD $0x5100e98d // sub w13, w12, #58 + WORD $0x31002dbf // cmn w13, #11 + WORD $0x54000689 // b.ls LBB0_15 $208(%rip) +LBB0_4: + WORD $0x7100c19f // cmp w12, #48 + WORD $0x540001c1 // b.ne LBB0_7 $56(%rip) + WORD $0x9100050c // add x12, x8, #1 + WORD $0xeb09011f // cmp x8, x9 + WORD $0x54000682 // b.hs LBB0_16 $208(%rip) + WORD $0x386c694d // ldrb w13, [x10, x12] + WORD $0x5100b9ad // sub w13, w13, #46 + WORD $0x7100ddbf // cmp w13, #55 + WORD $0x5280002e // mov w14, #1 + WORD $0x9acd21cd // lsl x13, x14, x13 + WORD $0xb20903ee // mov x14, #36028797027352576 + WORD $0xf280002e // movk x14, #1 + WORD $0x8a0e01ad // and x13, x13, x14 + WORD $0xfa4099a4 // ccmp x13, #0, #4, ls + WORD $0x54000540 // b.eq LBB0_16 $168(%rip) +LBB0_7: + WORD $0xd280000c // mov x12, #0 + WORD $0xeb09011f // cmp x8, x9 + WORD $0x9a89810d // csel x13, x8, x9, hi + WORD $0x5280014e // mov w14, #10 +LBB0_8: + WORD $0xeb0801bf // cmp x13, x8 + WORD $0x540006c0 // b.eq LBB0_23 $216(%rip) + WORD $0x38a8694f // ldrsb x15, [x10, x8] + WORD $0x5100c1f0 // sub w16, w15, #48 + WORD $0x12001e10 // and w16, w16, #0xff + WORD $0x7100261f // cmp w16, #9 + WORD $0x54000448 // b.hi LBB0_17 $136(%rip) + WORD $0x9b4e7d90 // smulh x16, x12, x14 + WORD $0x8b0c098c // add x12, x12, x12, lsl #2 + WORD $0xd37ff98c // lsl x12, x12, #1 + WORD $0xeb8cfe1f // cmp x16, x12, asr #63 + WORD $0x540000c1 // b.ne LBB0_12 $24(%rip) + WORD $0x91000508 // add x8, x8, #1 + WORD $0x5100c1ef // sub w15, w15, #48 + WORD $0x9b0b7def // mul x15, x15, x11 + WORD $0xab0f018c // adds x12, x12, x15 + WORD $0x54fffe07 // b.vc LBB0_8 $-64(%rip) +LBB0_12: + WORD $0xd1000508 // sub x8, x8, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x92800088 // mov x8, #-5 + WORD $0xf9000048 // str x8, [x2] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_13: + WORD $0xf9000029 // str x9, [x1] + WORD $0x92800008 // mov x8, #-1 + WORD $0xf9000048 // str x8, [x2] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_14: + WORD $0x5280002b // mov w11, #1 + WORD $0x5100e98d // sub w13, w12, #58 + WORD $0x31002dbf // cmn w13, #11 + WORD $0x54fff9c8 // b.hi LBB0_4 $-200(%rip) +LBB0_15: + WORD $0xf9000028 // str x8, [x1] + WORD $0x92800028 // mov x8, #-2 + WORD $0xf9000048 // str x8, [x2] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_16: + WORD $0xf900002c // str x12, [x1] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_17: + WORD $0xeb09011f // cmp x8, x9 + WORD $0x540001a2 // b.hs LBB0_22 $52(%rip) + WORD $0x38686949 // ldrb w9, [x10, x8] + WORD $0x7100b93f // cmp w9, #46 + WORD $0x540000a0 // b.eq LBB0_21 $20(%rip) + WORD $0x7101153f // cmp w9, #69 + WORD $0x54000060 // b.eq LBB0_21 $12(%rip) + WORD $0x7101953f // cmp w9, #101 + WORD $0x540000c1 // b.ne LBB0_22 $24(%rip) +LBB0_21: + WORD $0xf9000028 // str x8, [x1] + WORD $0x928000a8 // mov x8, #-6 + WORD $0xf9000048 // str x8, [x2] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_22: + WORD $0xaa0803ed // mov x13, x8 +LBB0_23: + WORD $0xf900002d // str x13, [x1] + WORD $0xf900084c // str x12, [x2, #16] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__vsigned(SB), $0-24 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $64, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_vsigned: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + MOVD v+16(FP), R2 + CALL ·__vsigned_arm64_entry__+24(SB) // _vsigned + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/vsigned_subr_arm64.go b/internal/native/neon/vsigned_subr_arm64.go new file mode 100644 index 000000000..aafda90c3 --- /dev/null +++ b/internal/native/neon/vsigned_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __vsigned_arm64_entry__() uintptr + +var ( + _subr__vsigned uintptr = __vsigned_arm64_entry__() + 12 +) + +const ( + _stack__vsigned = 32 +) + +var ( + _ = _subr__vsigned +) + +const ( + _ = _stack__vsigned +) diff --git a/internal/native/neon/vstring_arm64.go b/internal/native/neon/vstring_arm64.go new file mode 100644 index 000000000..5232c81ee --- /dev/null +++ b/internal/native/neon/vstring_arm64.go @@ -0,0 +1,32 @@ + +/* + * 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 neon + +import ( + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func vstring(s *string, p *int, v *types.JsonState, flags uint64) { + __vstring(s, p, v, flags) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vstring(s *string, p *int, v *types.JsonState, flags uint64) diff --git a/internal/native/neon/vstring_arm64.s b/internal/native/neon/vstring_arm64.s new file mode 100644 index 000000000..4fa5b3b8b --- /dev/null +++ b/internal/native/neon/vstring_arm64.s @@ -0,0 +1,644 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__vstring_arm64_entry__(SB), NOSPLIT, $32 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret + WORD $0x00000000 // .p2align 4, 0x00 +lCPI0_0: + WORD $0x08040201 + WORD $0x80402010 + WORD $0x08040201 + WORD $0x80402010 + // // .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 +// .byte 1 +// .byte 2 +// .byte 4 +// .byte 8 +// .byte 16 +// .byte 32 +// .byte 64 +// .byte 128 + +lCPI0_1: + WORD $0x09010800 + WORD $0x0b030a02 + WORD $0x0d050c04 + WORD $0x0f070e06 + // // .byte 0 +// .byte 8 +// .byte 1 +// .byte 9 +// .byte 2 +// .byte 10 +// .byte 3 +// .byte 11 +// .byte 4 +// .byte 12 +// .byte 5 +// .byte 13 +// .byte 6 +// .byte 14 +// .byte 7 +// .byte 15 + +_vstring: + MOVD.W R30, -48(RSP) // WORD $0xf81d0ffe // str x30, [sp, #-48]! + WORD $0xa9024ff4 // stp x20, x19, [sp, #32] + WORD $0xf9400028 // ldr x8, [x1] + WORD $0x37280ca3 // tbnz w3, #5, LBB0_11 $404(%rip) + WORD $0xf9400409 // ldr x9, [x0, #8] + WORD $0xeb08012c // subs x12, x9, x8 + WORD $0x54003dc0 // b.eq LBB0_75 $1976(%rip) + WORD $0xf940000a // ldr x10, [x0] + WORD $0xf101019f // cmp x12, #64 + WORD $0x54002923 // b.lo LBB0_37 $1316(%rip) + WORD $0xd280000d // mov x13, #0 + WORD $0x92800009 // mov x9, #-1 + WORD $0x4f01e440 // movi.16b v0, #34 + WORD $0x4f02e781 // movi.16b v1, #92 +Lloh0: + WORD $0x10fffd4b // adr x11, lCPI0_0 $-88(%rip) +Lloh1: + WORD $0x3dc00162 // ldr q2, [x11, lCPI0_0@PAGEOFF] $0(%rip) +Lloh2: + WORD $0x10fffd8b // adr x11, lCPI0_1 $-80(%rip) +Lloh3: + WORD $0x3dc00163 // ldr q3, [x11, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0xaa0803ee // mov x14, x8 + WORD $0x9280000b // mov x11, #-1 +LBB0_4: + WORD $0x8b0e014f // add x15, x10, x14 + WORD $0xad4015e4 // ldp q4, q5, [x15] + WORD $0xad411de6 // ldp q6, q7, [x15, #32] + WORD $0x6e208c90 // cmeq.16b v16, v4, v0 + WORD $0x6e208cb1 // cmeq.16b v17, v5, v0 + WORD $0x6e208cd2 // cmeq.16b v18, v6, v0 + WORD $0x6e208cf3 // cmeq.16b v19, v7, v0 + WORD $0x6e218c84 // cmeq.16b v4, v4, v1 + WORD $0x6e218ca5 // cmeq.16b v5, v5, v1 + WORD $0x6e218cc6 // cmeq.16b v6, v6, v1 + WORD $0x6e218ce7 // cmeq.16b v7, v7, v1 + WORD $0x4e221e10 // and.16b v16, v16, v2 + WORD $0x4e030210 // tbl.16b v16, { v16 }, v3 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e26020f // fmov w15, s16 + WORD $0x4e221e30 // and.16b v16, v17, v2 + WORD $0x4e030210 // tbl.16b v16, { v16 }, v3 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e260210 // fmov w16, s16 + WORD $0x4e221e50 // and.16b v16, v18, v2 + WORD $0x4e030210 // tbl.16b v16, { v16 }, v3 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e260211 // fmov w17, s16 + WORD $0x4e221e70 // and.16b v16, v19, v2 + WORD $0x4e030210 // tbl.16b v16, { v16 }, v3 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e260203 // fmov w3, s16 + WORD $0x4e221c84 // and.16b v4, v4, v2 + WORD $0x4e030084 // tbl.16b v4, { v4 }, v3 + WORD $0x4e71b884 // addv.8h h4, v4 + WORD $0x1e260084 // fmov w4, s4 + WORD $0x4e221ca4 // and.16b v4, v5, v2 + WORD $0x4e030084 // tbl.16b v4, { v4 }, v3 + WORD $0x4e71b884 // addv.8h h4, v4 + WORD $0x1e260085 // fmov w5, s4 + WORD $0x4e221cc4 // and.16b v4, v6, v2 + WORD $0x4e030084 // tbl.16b v4, { v4 }, v3 + WORD $0x4e71b884 // addv.8h h4, v4 + WORD $0x1e260086 // fmov w6, s4 + WORD $0x4e221ce4 // and.16b v4, v7, v2 + WORD $0x4e030084 // tbl.16b v4, { v4 }, v3 + WORD $0x4e71b884 // addv.8h h4, v4 + WORD $0x1e260087 // fmov w7, s4 + WORD $0xd3607e31 // lsl x17, x17, #32 + WORD $0xb3503c71 // bfi x17, x3, #48, #16 + WORD $0x53103e10 // lsl w16, w16, #16 + WORD $0xaa100230 // orr x16, x17, x16 + WORD $0xaa0f020f // orr x15, x16, x15 + WORD $0xd3607cd0 // lsl x16, x6, #32 + WORD $0xb3503cf0 // bfi x16, x7, #48, #16 + WORD $0x53103cb1 // lsl w17, w5, #16 + WORD $0xaa110210 // orr x16, x16, x17 + WORD $0xaa040210 // orr x16, x16, x4 + WORD $0xb5000110 // cbnz x16, LBB0_8 $32(%rip) + WORD $0xb50001ad // cbnz x13, LBB0_9 $52(%rip) + WORD $0xb50002ef // cbnz x15, LBB0_10 $92(%rip) +LBB0_7: + WORD $0xd101018c // sub x12, x12, #64 + WORD $0x910101ce // add x14, x14, #64 + WORD $0xf100fd9f // cmp x12, #63 + WORD $0x54fff8a8 // b.hi LBB0_4 $-236(%rip) + WORD $0x140000a1 // b LBB0_24 $644(%rip) +LBB0_8: + WORD $0xb100057f // cmn x11, #1 + WORD $0xdac00211 // rbit x17, x16 + WORD $0xdac01231 // clz x17, x17 + WORD $0x8b0e0231 // add x17, x17, x14 + WORD $0x9a911129 // csel x9, x9, x17, ne + WORD $0x9a91116b // csel x11, x11, x17, ne +LBB0_9: + WORD $0x8a2d0211 // bic x17, x16, x13 + WORD $0xaa1105a3 // orr x3, x13, x17, lsl #1 + WORD $0x8a23020d // bic x13, x16, x3 + WORD $0x9201f1ad // and x13, x13, #0xaaaaaaaaaaaaaaaa + WORD $0xab1101b0 // adds x16, x13, x17 + WORD $0x1a9f37ed // cset w13, hs + WORD $0xd37ffa10 // lsl x16, x16, #1 + WORD $0xd200f210 // eor x16, x16, #0x5555555555555555 + WORD $0x8a030210 // and x16, x16, x3 + WORD $0x8a3001ef // bic x15, x15, x16 + WORD $0xb4fffd6f // cbz x15, LBB0_7 $-84(%rip) +LBB0_10: + WORD $0xdac001ea // rbit x10, x15 + WORD $0xdac0114a // clz x10, x10 + WORD $0x8b0e014a // add x10, x10, x14 + WORD $0x9100054f // add x15, x10, #1 + WORD $0xb6f8104f // tbz x15, #63, LBB0_23 $520(%rip) + WORD $0x1400016e // b LBB0_69 $1464(%rip) +LBB0_11: + WORD $0xf9400409 // ldr x9, [x0, #8] + WORD $0xeb08012c // subs x12, x9, x8 + WORD $0x54003140 // b.eq LBB0_75 $1576(%rip) + WORD $0xf940000a // ldr x10, [x0] + WORD $0x10fff18f // adr x15, lCPI0_0 $-464(%rip) + WORD $0x10fff1ee // adr x14, lCPI0_1 $-452(%rip) + WORD $0xf101019f // cmp x12, #64 + WORD $0x54001d43 // b.lo LBB0_38 $936(%rip) + WORD $0xd280000b // mov x11, #0 + WORD $0x92800009 // mov x9, #-1 + WORD $0x4f01e440 // movi.16b v0, #34 + WORD $0x3dc001e1 // ldr q1, [x15, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x3dc001c2 // ldr q2, [x14, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x4f02e783 // movi.16b v3, #92 + WORD $0x4f01e404 // movi.16b v4, #32 + WORD $0xaa0803ed // mov x13, x8 +LBB0_14: + WORD $0x8b0d0150 // add x16, x10, x13 + WORD $0xad401e10 // ldp q16, q7, [x16] + WORD $0xad411606 // ldp q6, q5, [x16, #32] + WORD $0x6e208e11 // cmeq.16b v17, v16, v0 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260230 // fmov w16, s17 + WORD $0x6e208cf1 // cmeq.16b v17, v7, v0 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260231 // fmov w17, s17 + WORD $0x6e208cd1 // cmeq.16b v17, v6, v0 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260223 // fmov w3, s17 + WORD $0x6e208cb1 // cmeq.16b v17, v5, v0 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260224 // fmov w4, s17 + WORD $0x6e238e11 // cmeq.16b v17, v16, v3 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260225 // fmov w5, s17 + WORD $0x6e238cf1 // cmeq.16b v17, v7, v3 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260226 // fmov w6, s17 + WORD $0x6e238cd1 // cmeq.16b v17, v6, v3 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260227 // fmov w7, s17 + WORD $0x6e238cb1 // cmeq.16b v17, v5, v3 + WORD $0x4e211e31 // and.16b v17, v17, v1 + WORD $0x4e020231 // tbl.16b v17, { v17 }, v2 + WORD $0x4e71ba31 // addv.8h h17, v17 + WORD $0x1e260233 // fmov w19, s17 + WORD $0xd3607c63 // lsl x3, x3, #32 + WORD $0xb3503c83 // bfi x3, x4, #48, #16 + WORD $0x53103e31 // lsl w17, w17, #16 + WORD $0xaa110071 // orr x17, x3, x17 + WORD $0xaa100230 // orr x16, x17, x16 + WORD $0xd3607cf1 // lsl x17, x7, #32 + WORD $0xb3503e71 // bfi x17, x19, #48, #16 + WORD $0x53103cc3 // lsl w3, w6, #16 + WORD $0xaa030231 // orr x17, x17, x3 + WORD $0xaa050231 // orr x17, x17, x5 + WORD $0xb5000451 // cbnz x17, LBB0_19 $136(%rip) + WORD $0xb50004cb // cbnz x11, LBB0_20 $152(%rip) +LBB0_16: + WORD $0x6e303490 // cmhi.16b v16, v4, v16 + WORD $0x4e211e10 // and.16b v16, v16, v1 + WORD $0x4e020210 // tbl.16b v16, { v16 }, v2 + WORD $0x4e71ba10 // addv.8h h16, v16 + WORD $0x1e260211 // fmov w17, s16 + WORD $0x6e273487 // cmhi.16b v7, v4, v7 + WORD $0x4e211ce7 // and.16b v7, v7, v1 + WORD $0x4e0200e7 // tbl.16b v7, { v7 }, v2 + WORD $0x4e71b8e7 // addv.8h h7, v7 + WORD $0x1e2600e3 // fmov w3, s7 + WORD $0x6e263486 // cmhi.16b v6, v4, v6 + WORD $0x4e211cc6 // and.16b v6, v6, v1 + WORD $0x4e0200c6 // tbl.16b v6, { v6 }, v2 + WORD $0x4e71b8c6 // addv.8h h6, v6 + WORD $0x1e2600c4 // fmov w4, s6 + WORD $0x6e253485 // cmhi.16b v5, v4, v5 + WORD $0x4e211ca5 // and.16b v5, v5, v1 + WORD $0x4e0200a5 // tbl.16b v5, { v5 }, v2 + WORD $0x4e71b8a5 // addv.8h h5, v5 + WORD $0x1e2600a5 // fmov w5, s5 + WORD $0xd3607c84 // lsl x4, x4, #32 + WORD $0xb3503ca4 // bfi x4, x5, #48, #16 + WORD $0x53103c63 // lsl w3, w3, #16 + WORD $0xaa030083 // orr x3, x4, x3 + WORD $0xaa110071 // orr x17, x3, x17 + WORD $0xb50002f0 // cbnz x16, LBB0_21 $92(%rip) + WORD $0xb50009f1 // cbnz x17, LBB0_29 $316(%rip) + WORD $0xd101018c // sub x12, x12, #64 + WORD $0x910101ad // add x13, x13, #64 + WORD $0xf100fd9f // cmp x12, #63 + WORD $0x54fff568 // b.hi LBB0_14 $-340(%rip) + WORD $0x1400004c // b LBB0_30 $304(%rip) +LBB0_19: + WORD $0xb100053f // cmn x9, #1 + WORD $0xdac00223 // rbit x3, x17 + WORD $0xdac01063 // clz x3, x3 + WORD $0x8b0d0063 // add x3, x3, x13 + WORD $0x9a831129 // csel x9, x9, x3, ne +LBB0_20: + WORD $0x8a2b0223 // bic x3, x17, x11 + WORD $0xaa030564 // orr x4, x11, x3, lsl #1 + WORD $0x8a24022b // bic x11, x17, x4 + WORD $0x9201f16b // and x11, x11, #0xaaaaaaaaaaaaaaaa + WORD $0xab030171 // adds x17, x11, x3 + WORD $0x1a9f37eb // cset w11, hs + WORD $0xd37ffa31 // lsl x17, x17, #1 + WORD $0xd200f231 // eor x17, x17, #0x5555555555555555 + WORD $0x8a040231 // and x17, x17, x4 + WORD $0x8a310210 // bic x16, x16, x17 + WORD $0x17ffffd1 // b LBB0_16 $-188(%rip) +LBB0_21: + WORD $0xdac0020a // rbit x10, x16 + WORD $0xdac0114a // clz x10, x10 + WORD $0xdac0022b // rbit x11, x17 + WORD $0xdac0116b // clz x11, x11 + WORD $0xeb0a017f // cmp x11, x10 + WORD $0x54001ee3 // b.lo LBB0_70 $988(%rip) + WORD $0x8b0d014a // add x10, x10, x13 + WORD $0x9100054f // add x15, x10, #1 + WORD $0xb7f81dcf // tbnz x15, #63, LBB0_69 $952(%rip) +LBB0_23: + WORD $0xf900002f // str x15, [x1] + WORD $0x528000ea // mov w10, #7 + WORD $0xf900004a // str x10, [x2] + WORD $0xeb0f013f // cmp x9, x15 + WORD $0xda9fb129 // csinv x9, x9, xzr, lt + WORD $0xa9012448 // stp x8, x9, [x2, #16] + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_24: + WORD $0x8b0e014e // add x14, x10, x14 + WORD $0xf100818f // subs x15, x12, #32 + WORD $0x54001063 // b.lo LBB0_42 $524(%rip) +LBB0_25: + WORD $0xad4005c0 // ldp q0, q1, [x14] + WORD $0x4f01e442 // movi.16b v2, #34 + WORD $0x6e228c03 // cmeq.16b v3, v0, v2 + WORD $0x6e228c22 // cmeq.16b v2, v1, v2 + WORD $0x4f02e784 // movi.16b v4, #92 + WORD $0x6e248c00 // cmeq.16b v0, v0, v4 + WORD $0x6e248c21 // cmeq.16b v1, v1, v4 +Lloh4: + WORD $0x10ffdfac // adr x12, lCPI0_0 $-1036(%rip) +Lloh5: + WORD $0x3dc00184 // ldr q4, [x12, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x4e241c63 // and.16b v3, v3, v4 +Lloh6: + WORD $0x10ffdfcc // adr x12, lCPI0_1 $-1032(%rip) +Lloh7: + WORD $0x3dc00185 // ldr q5, [x12, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x4e050063 // tbl.16b v3, { v3 }, v5 + WORD $0x4e71b863 // addv.8h h3, v3 + WORD $0x1e26006c // fmov w12, s3 + WORD $0x4e241c42 // and.16b v2, v2, v4 + WORD $0x4e050042 // tbl.16b v2, { v2 }, v5 + WORD $0x4e71b842 // addv.8h h2, v2 + WORD $0x1e260051 // fmov w17, s2 + WORD $0x4e241c00 // and.16b v0, v0, v4 + WORD $0x4e050000 // tbl.16b v0, { v0 }, v5 + WORD $0x4e71b800 // addv.8h h0, v0 + WORD $0x1e260010 // fmov w16, s0 + WORD $0x4e241c20 // and.16b v0, v1, v4 + WORD $0x4e050000 // tbl.16b v0, { v0 }, v5 + WORD $0x4e71b800 // addv.8h h0, v0 + WORD $0x1e260003 // fmov w3, s0 + WORD $0x33103e2c // bfi w12, w17, #16, #16 + WORD $0x33103c70 // bfi w16, w3, #16, #16 + WORD $0x350009d0 // cbnz w16, LBB0_39 $312(%rip) + WORD $0xb5000a8d // cbnz x13, LBB0_40 $336(%rip) + WORD $0xb4000c2c // cbz x12, LBB0_41 $388(%rip) +LBB0_28: + WORD $0xdac0018b // rbit x11, x12 + WORD $0xdac0116b // clz x11, x11 + WORD $0xcb0a01ca // sub x10, x14, x10 + WORD $0x14000037 // b LBB0_36 $220(%rip) +LBB0_29: + WORD $0x9280002f // mov x15, #-2 + WORD $0x140000bc // b LBB0_69 $752(%rip) +LBB0_30: + WORD $0x8b0d014d // add x13, x10, x13 + WORD $0xf1008190 // subs x16, x12, #32 + WORD $0x54001303 // b.lo LBB0_59 $608(%rip) +LBB0_31: + WORD $0xad4005a0 // ldp q0, q1, [x13] + WORD $0x4f01e442 // movi.16b v2, #34 + WORD $0x6e228c03 // cmeq.16b v3, v0, v2 + WORD $0x3dc001e4 // ldr q4, [x15, lCPI0_0@PAGEOFF] $0(%rip) + WORD $0x4e241c63 // and.16b v3, v3, v4 + WORD $0x3dc001c5 // ldr q5, [x14, lCPI0_1@PAGEOFF] $0(%rip) + WORD $0x4e050063 // tbl.16b v3, { v3 }, v5 + WORD $0x4e71b863 // addv.8h h3, v3 + WORD $0x1e26006c // fmov w12, s3 + WORD $0x6e228c22 // cmeq.16b v2, v1, v2 + WORD $0x4e241c42 // and.16b v2, v2, v4 + WORD $0x4e050042 // tbl.16b v2, { v2 }, v5 + WORD $0x4e71b842 // addv.8h h2, v2 + WORD $0x1e260051 // fmov w17, s2 + WORD $0x4f02e782 // movi.16b v2, #92 + WORD $0x6e228c03 // cmeq.16b v3, v0, v2 + WORD $0x4e241c63 // and.16b v3, v3, v4 + WORD $0x4e050063 // tbl.16b v3, { v3 }, v5 + WORD $0x4e71b863 // addv.8h h3, v3 + WORD $0x1e26006f // fmov w15, s3 + WORD $0x6e228c22 // cmeq.16b v2, v1, v2 + WORD $0x4e241c42 // and.16b v2, v2, v4 + WORD $0x4e050042 // tbl.16b v2, { v2 }, v5 + WORD $0x4e71b842 // addv.8h h2, v2 + WORD $0x1e260043 // fmov w3, s2 + WORD $0x4f01e402 // movi.16b v2, #32 + WORD $0x6e203440 // cmhi.16b v0, v2, v0 + WORD $0x4e241c00 // and.16b v0, v0, v4 + WORD $0x4e050000 // tbl.16b v0, { v0 }, v5 + WORD $0x4e71b800 // addv.8h h0, v0 + WORD $0x1e26000e // fmov w14, s0 + WORD $0x6e213440 // cmhi.16b v0, v2, v1 + WORD $0x4e241c00 // and.16b v0, v0, v4 + WORD $0x4e050000 // tbl.16b v0, { v0 }, v5 + WORD $0x4e71b800 // addv.8h h0, v0 + WORD $0x1e260004 // fmov w4, s0 + WORD $0x33103e2c // bfi w12, w17, #16, #16 + WORD $0x33103c6f // bfi w15, w3, #16, #16 + WORD $0x33103c8e // bfi w14, w4, #16, #16 + WORD $0x35000b2f // cbnz w15, LBB0_55 $356(%rip) + WORD $0xb5000bcb // cbnz x11, LBB0_56 $376(%rip) + WORD $0xb4000d6c // cbz x12, LBB0_57 $428(%rip) +LBB0_34: + WORD $0xdac0018b // rbit x11, x12 + WORD $0xdac0116b // clz x11, x11 + WORD $0xdac001cc // rbit x12, x14 + WORD $0xdac0118c // clz x12, x12 + WORD $0xeb0b019f // cmp x12, x11 + WORD $0x540011e3 // b.lo LBB0_70 $572(%rip) + WORD $0xcb0a01aa // sub x10, x13, x10 +LBB0_36: + WORD $0x8b0b014a // add x10, x10, x11 + WORD $0x9100054f // add x15, x10, #1 + WORD $0xb6fff30f // tbz x15, #63, LBB0_23 $-416(%rip) + WORD $0x14000084 // b LBB0_69 $528(%rip) +LBB0_37: + WORD $0xd280000d // mov x13, #0 + WORD $0x8b08014e // add x14, x10, x8 + WORD $0x92800009 // mov x9, #-1 + WORD $0x9280000b // mov x11, #-1 + WORD $0xf100818f // subs x15, x12, #32 + WORD $0x54fff3a2 // b.hs LBB0_25 $-396(%rip) + WORD $0x1400001e // b LBB0_42 $120(%rip) +LBB0_38: + WORD $0xd280000b // mov x11, #0 + WORD $0x8b08014d // add x13, x10, x8 + WORD $0x92800009 // mov x9, #-1 + WORD $0xf1008190 // subs x16, x12, #32 + WORD $0x54fff802 // b.hs LBB0_31 $-256(%rip) + WORD $0x14000056 // b LBB0_59 $344(%rip) +LBB0_39: + WORD $0xdac00211 // rbit x17, x16 + WORD $0xdac01231 // clz x17, x17 + WORD $0xcb0a01c3 // sub x3, x14, x10 + WORD $0x8b030231 // add x17, x17, x3 + WORD $0xb100057f // cmn x11, #1 + WORD $0x9a911129 // csel x9, x9, x17, ne + WORD $0x9a91116b // csel x11, x11, x17, ne +LBB0_40: + WORD $0x0a2d0211 // bic w17, w16, w13 + WORD $0x531f7a23 // lsl w3, w17, #1 + WORD $0x331f7a2d // bfi w13, w17, #1, #31 + WORD $0x0a230210 // bic w16, w16, w3 + WORD $0x1201f210 // and w16, w16, #0xaaaaaaaa + WORD $0x2b110210 // adds w16, w16, w17 + WORD $0x3200f3f1 // mov w17, #1431655765 + WORD $0x4a100630 // eor w16, w17, w16, lsl #1 + WORD $0x0a0d020d // and w13, w16, w13 + WORD $0x1a9f37f0 // cset w16, hs + WORD $0x2a2d03ed // mvn w13, w13 + WORD $0x8a0c01ac // and x12, x13, x12 + WORD $0xaa1003ed // mov x13, x16 + WORD $0xb5fff42c // cbnz x12, LBB0_28 $-380(%rip) +LBB0_41: + WORD $0x910081ce // add x14, x14, #32 + WORD $0xaa0f03ec // mov x12, x15 +LBB0_42: + WORD $0xb5000d8d // cbnz x13, LBB0_71 $432(%rip) + WORD $0xb40003ec // cbz x12, LBB0_52 $124(%rip) +LBB0_44: + WORD $0xcb0a03ed // neg x13, x10 +LBB0_45: + WORD $0xd2800010 // mov x16, #0 +LBB0_46: + WORD $0x387069cf // ldrb w15, [x14, x16] + WORD $0x710089ff // cmp w15, #34 + WORD $0x54000300 // b.eq LBB0_51 $96(%rip) + WORD $0x710171ff // cmp w15, #92 + WORD $0x540000a0 // b.eq LBB0_49 $20(%rip) + WORD $0x91000610 // add x16, x16, #1 + WORD $0xeb10019f // cmp x12, x16 + WORD $0x54ffff21 // b.ne LBB0_46 $-28(%rip) + WORD $0x14000017 // b LBB0_53 $92(%rip) +LBB0_49: + WORD $0xd100058f // sub x15, x12, #1 + WORD $0xeb1001ff // cmp x15, x16 + WORD $0x54000de0 // b.eq LBB0_75 $444(%rip) + WORD $0x8b0e01af // add x15, x13, x14 + WORD $0x8b1001ef // add x15, x15, x16 + WORD $0xb100057f // cmn x11, #1 + WORD $0x9a8901e9 // csel x9, x15, x9, eq + WORD $0x9a8b01eb // csel x11, x15, x11, eq + WORD $0x8b1001ce // add x14, x14, x16 + WORD $0x910009ce // add x14, x14, #2 + WORD $0xcb10018f // sub x15, x12, x16 + WORD $0xd1000991 // sub x17, x12, #2 + WORD $0xd10009ec // sub x12, x15, #2 + WORD $0x9280000f // mov x15, #-1 + WORD $0xeb10023f // cmp x17, x16 + WORD $0x54fffce1 // b.ne LBB0_45 $-100(%rip) + WORD $0x14000042 // b LBB0_69 $264(%rip) +LBB0_51: + WORD $0x8b1001cb // add x11, x14, x16 + WORD $0x9100056e // add x14, x11, #1 +LBB0_52: + WORD $0xcb0a01cf // sub x15, x14, x10 + WORD $0xb6ffea2f // tbz x15, #63, LBB0_23 $-700(%rip) + WORD $0x1400003d // b LBB0_69 $244(%rip) +LBB0_53: + WORD $0x710089ff // cmp w15, #34 + WORD $0x54000b41 // b.ne LBB0_75 $360(%rip) + WORD $0x8b0c01ce // add x14, x14, x12 + WORD $0x17fffffa // b LBB0_52 $-24(%rip) +LBB0_55: + WORD $0xdac001f1 // rbit x17, x15 + WORD $0xdac01231 // clz x17, x17 + WORD $0xcb0a01a3 // sub x3, x13, x10 + WORD $0x8b110071 // add x17, x3, x17 + WORD $0xb100053f // cmn x9, #1 + WORD $0x9a911129 // csel x9, x9, x17, ne +LBB0_56: + WORD $0x0a2b01f1 // bic w17, w15, w11 + WORD $0x531f7a23 // lsl w3, w17, #1 + WORD $0x331f7a2b // bfi w11, w17, #1, #31 + WORD $0x0a2301ef // bic w15, w15, w3 + WORD $0x1201f1ef // and w15, w15, #0xaaaaaaaa + WORD $0x2b1101ef // adds w15, w15, w17 + WORD $0x3200f3f1 // mov w17, #1431655765 + WORD $0x4a0f062f // eor w15, w17, w15, lsl #1 + WORD $0x0a0b01eb // and w11, w15, w11 + WORD $0x1a9f37ef // cset w15, hs + WORD $0x2a2b03eb // mvn w11, w11 + WORD $0x8a0c016c // and x12, x11, x12 + WORD $0xaa0f03eb // mov x11, x15 + WORD $0xb5fff2ec // cbnz x12, LBB0_34 $-420(%rip) +LBB0_57: + WORD $0x3500054e // cbnz w14, LBB0_70 $168(%rip) + WORD $0x910081ad // add x13, x13, #32 + WORD $0xaa1003ec // mov x12, x16 +LBB0_59: + WORD $0xb500070b // cbnz x11, LBB0_73 $224(%rip) + WORD $0xb40007ec // cbz x12, LBB0_75 $252(%rip) +LBB0_61: + WORD $0x9280002b // mov x11, #-2 + WORD $0x5280004e // mov w14, #2 +LBB0_62: + WORD $0x394001af // ldrb w15, [x13] + WORD $0x710089ff // cmp w15, #34 + WORD $0x54000300 // b.eq LBB0_68 $96(%rip) + WORD $0x710171ff // cmp w15, #92 + WORD $0x54000140 // b.eq LBB0_66 $40(%rip) + WORD $0x710081ff // cmp w15, #32 + WORD $0x540003a3 // b.lo LBB0_70 $116(%rip) + WORD $0x92800010 // mov x16, #-1 + WORD $0x5280002f // mov w15, #1 + WORD $0x8b0f01ad // add x13, x13, x15 + WORD $0x9280000f // mov x15, #-1 + WORD $0xab0c020c // adds x12, x16, x12 + WORD $0x54fffe81 // b.ne LBB0_62 $-48(%rip) + WORD $0x14000010 // b LBB0_69 $64(%rip) +LBB0_66: + WORD $0xf100059f // cmp x12, #1 + WORD $0x540005a0 // b.eq LBB0_75 $180(%rip) + WORD $0xcb0a01af // sub x15, x13, x10 + WORD $0xb100053f // cmn x9, #1 + WORD $0x9a8f1129 // csel x9, x9, x15, ne + WORD $0x9a8e11cf // csel x15, x14, x14, ne + WORD $0x9a8b1170 // csel x16, x11, x11, ne + WORD $0x8b0f01ad // add x13, x13, x15 + WORD $0x9280000f // mov x15, #-1 + WORD $0xab0c020c // adds x12, x16, x12 + WORD $0x54fffd01 // b.ne LBB0_62 $-96(%rip) + WORD $0x14000004 // b LBB0_69 $16(%rip) +LBB0_68: + WORD $0xcb0a01aa // sub x10, x13, x10 + WORD $0x9100054f // add x15, x10, #1 + WORD $0xb6ffe28f // tbz x15, #63, LBB0_23 $-944(%rip) +LBB0_69: + WORD $0xf9400408 // ldr x8, [x0, #8] + WORD $0xf9000028 // str x8, [x1] + WORD $0xf900004f // str x15, [x2] + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_70: + WORD $0x9280002f // mov x15, #-2 + WORD $0xf9400408 // ldr x8, [x0, #8] + WORD $0xf9000028 // str x8, [x1] + WORD $0xf900004f // str x15, [x2] + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret +LBB0_71: + WORD $0xb400024c // cbz x12, LBB0_75 $72(%rip) + WORD $0xaa2a03ed // mvn x13, x10 + WORD $0x8b0d01cd // add x13, x14, x13 + WORD $0xb100057f // cmn x11, #1 + WORD $0x9a8901a9 // csel x9, x13, x9, eq + WORD $0x9a8b01ab // csel x11, x13, x11, eq + WORD $0x910005ce // add x14, x14, #1 + WORD $0xd100058c // sub x12, x12, #1 + WORD $0xb5fff1cc // cbnz x12, LBB0_44 $-456(%rip) + WORD $0x17ffffab // b LBB0_52 $-340(%rip) +LBB0_73: + WORD $0xb400010c // cbz x12, LBB0_75 $32(%rip) + WORD $0xaa2a03eb // mvn x11, x10 + WORD $0x8b0b01ab // add x11, x13, x11 + WORD $0xb100053f // cmn x9, #1 + WORD $0x9a890169 // csel x9, x11, x9, eq + WORD $0x910005ad // add x13, x13, #1 + WORD $0xd100058c // sub x12, x12, #1 + WORD $0xb5fff86c // cbnz x12, LBB0_61 $-244(%rip) +LBB0_75: + WORD $0x9280000f // mov x15, #-1 + WORD $0xf9400408 // ldr x8, [x0, #8] + WORD $0xf9000028 // str x8, [x1] + WORD $0xf900004f // str x15, [x2] + WORD $0xa9424ff4 // ldp x20, x19, [sp, #32] + WORD $0x9100c3ff // add sp, sp, #48 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__vstring(SB), $0-32 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $80, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_vstring: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + MOVD v+16(FP), R2 + MOVD flags+24(FP), R3 + CALL ·__vstring_arm64_entry__+60(SB) // _vstring + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/vstring_subr_arm64.go b/internal/native/neon/vstring_subr_arm64.go new file mode 100644 index 000000000..42d1716ad --- /dev/null +++ b/internal/native/neon/vstring_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __vstring_arm64_entry__() uintptr + +var ( + _subr__vstring uintptr = __vstring_arm64_entry__() + 48 +) + +const ( + _stack__vstring = 48 +) + +var ( + _ = _subr__vstring +) + +const ( + _ = _stack__vstring +) diff --git a/internal/native/neon/vunsigned_arm64.go b/internal/native/neon/vunsigned_arm64.go new file mode 100644 index 000000000..02019f756 --- /dev/null +++ b/internal/native/neon/vunsigned_arm64.go @@ -0,0 +1,32 @@ + +/* + * 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 neon + +import ( + `github.com/bytedance/sonic/internal/native/types` +) + +//go:nosplit +func vunsigned(s *string, p *int, v *types.JsonState) { + __vunsigned(s, p, v) +} + +//go:nosplit +//go:noescape +//goland:noinspection GoUnusedParameter +func __vunsigned(s *string, p *int, v *types.JsonState) diff --git a/internal/native/neon/vunsigned_arm64.s b/internal/native/neon/vunsigned_arm64.s new file mode 100644 index 000000000..8b6f9927d --- /dev/null +++ b/internal/native/neon/vunsigned_arm64.s @@ -0,0 +1,138 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +#include "go_asm.h" +#include "funcdata.h" +#include "textflag.h" + +TEXT ·__vunsigned_arm64_entry__(SB), NOSPLIT, $16 + NO_LOCAL_POINTERS + WORD $0x10000000 // adr x0, . $0(%rip) + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_vunsigned: + MOVD.W R30, -32(RSP) // WORD $0xf81e0ffe // str x30, [sp, #-32]! + WORD $0xf9400028 // ldr x8, [x1] + WORD $0xa940240a // ldp x10, x9, [x0] + WORD $0x5280012b // mov w11, #9 + WORD $0xa900fc5f // stp xzr, xzr, [x2, #8] + WORD $0xf900004b // str x11, [x2] + WORD $0xf940002b // ldr x11, [x1] + WORD $0xf9000c4b // str x11, [x2, #24] + WORD $0xeb09011f // cmp x8, x9 + WORD $0x54000122 // b.hs LBB0_3 $36(%rip) + WORD $0x3868694b // ldrb w11, [x10, x8] + WORD $0x7100b57f // cmp w11, #45 + WORD $0x54000161 // b.ne LBB0_4 $44(%rip) +LBB0_2: + WORD $0xf9000028 // str x8, [x1] + WORD $0x928000a8 // mov x8, #-6 + WORD $0xf9000048 // str x8, [x2] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_3: + WORD $0xf9000029 // str x9, [x1] + WORD $0x92800008 // mov x8, #-1 + WORD $0xf9000048 // str x8, [x2] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_4: + WORD $0x5100e96c // sub w12, w11, #58 + WORD $0x31002d9f // cmn w12, #11 + WORD $0x540000c8 // b.hi LBB0_6 $24(%rip) + WORD $0xf9000028 // str x8, [x1] + WORD $0x92800028 // mov x8, #-2 + WORD $0xf9000048 // str x8, [x2] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_6: + WORD $0x7100c17f // cmp w11, #48 + WORD $0x54000181 // b.ne LBB0_8 $48(%rip) + WORD $0x9100050b // add x11, x8, #1 + WORD $0x386b694c // ldrb w12, [x10, x11] + WORD $0x5100b98c // sub w12, w12, #46 + WORD $0x7100dd9f // cmp w12, #55 + WORD $0x5280002d // mov w13, #1 + WORD $0x9acc21ac // lsl x12, x13, x12 + WORD $0xb20903ed // mov x13, #36028797027352576 + WORD $0xf280002d // movk x13, #1 + WORD $0x8a0d018c // and x12, x12, x13 + WORD $0xfa409984 // ccmp x12, #0, #4, ls + WORD $0x54000560 // b.eq LBB0_21 $172(%rip) +LBB0_8: + WORD $0xd280000b // mov x11, #0 + WORD $0xeb08013f // cmp x9, x8 + WORD $0x9a88812c // csel x12, x9, x8, hi + WORD $0x5280014d // mov w13, #10 +LBB0_9: + WORD $0xeb08019f // cmp x12, x8 + WORD $0x54000420 // b.eq LBB0_20 $132(%rip) + WORD $0x38e8694e // ldrsb w14, [x10, x8] + WORD $0x5100c1ce // sub w14, w14, #48 + WORD $0x710025df // cmp w14, #9 + WORD $0x54000268 // b.hi LBB0_15 $76(%rip) + WORD $0x9bcd7d6f // umulh x15, x11, x13 + WORD $0xeb0f03ff // cmp xzr, x15 + WORD $0x54000141 // b.ne LBB0_14 $40(%rip) + WORD $0x8b0b096b // add x11, x11, x11, lsl #2 + WORD $0xd37ff96b // lsl x11, x11, #1 + WORD $0x91000508 // add x8, x8, #1 + WORD $0xab0e016b // adds x11, x11, x14 + WORD $0xba1f03ef // adcs x15, xzr, xzr + WORD $0x934001ee // sbfx x14, x15, #0, #1 + WORD $0xca0f01cf // eor x15, x14, x15 + WORD $0xb500004f // cbnz x15, LBB0_14 $8(%rip) + WORD $0xb6fffdee // tbz x14, #63, LBB0_9 $-68(%rip) +LBB0_14: + WORD $0xd1000508 // sub x8, x8, #1 + WORD $0xf9000028 // str x8, [x1] + WORD $0x92800088 // mov x8, #-5 + WORD $0xf9000048 // str x8, [x2] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_15: + WORD $0xeb09011f // cmp x8, x9 + WORD $0x54000102 // b.hs LBB0_19 $32(%rip) + WORD $0x38686949 // ldrb w9, [x10, x8] + WORD $0x7100b93f // cmp w9, #46 + WORD $0x54fff820 // b.eq LBB0_2 $-252(%rip) + WORD $0x7101153f // cmp w9, #69 + WORD $0x54fff7e0 // b.eq LBB0_2 $-260(%rip) + WORD $0x7101953f // cmp w9, #101 + WORD $0x54fff7a0 // b.eq LBB0_2 $-268(%rip) +LBB0_19: + WORD $0xaa0803ec // mov x12, x8 +LBB0_20: + WORD $0xf900002c // str x12, [x1] + WORD $0xf900084b // str x11, [x2, #16] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret +LBB0_21: + WORD $0xf900002b // str x11, [x1] + WORD $0x910083ff // add sp, sp, #32 + WORD $0xd65f03c0 // ret + // .p2align 2, 0x00 +_MASK_USE_NUMBER: + WORD $0x00000002 // .long 2 + +TEXT ·__vunsigned(SB), $0-24 + NO_LOCAL_POINTERS + +_entry: + MOVD 16(g), R16 + SUB $64, RSP, R17 + CMP R16, R17 + BLS _stack_grow + +_vunsigned: + MOVD s+0(FP), R0 + MOVD p+8(FP), R1 + MOVD v+16(FP), R2 + CALL ·__vunsigned_arm64_entry__+24(SB) // _vunsigned + RET + +_stack_grow: + MOVD R30, R3 + CALL runtime·morestack_noctxt<>(SB) + JMP _entry diff --git a/internal/native/neon/vunsigned_subr_arm64.go b/internal/native/neon/vunsigned_subr_arm64.go new file mode 100644 index 000000000..ce92338a7 --- /dev/null +++ b/internal/native/neon/vunsigned_subr_arm64.go @@ -0,0 +1,25 @@ +// +build !noasm !appengine +// Code generated by asm2asm, DO NOT EDIT. + +package neon + +//go:nosplit +//go:noescape +//goland:noinspection ALL +func __vunsigned_arm64_entry__() uintptr + +var ( + _subr__vunsigned uintptr = __vunsigned_arm64_entry__() + 12 +) + +const ( + _stack__vunsigned = 32 +) + +var ( + _ = _subr__vunsigned +) + +const ( + _ = _stack__vunsigned +) diff --git a/internal/native/recover_amd64_test.tmpl b/internal/native/recover_amd64_test.tmpl index f55e8bbd2..b8aeb38cf 100644 --- a/internal/native/recover_amd64_test.tmpl +++ b/internal/native/recover_amd64_test.tmpl @@ -35,7 +35,6 @@ var ( var stubs = []loader.GoC{ {"_f32toa", nil, &__f32toa}, {"_f64toa", nil, &__f64toa}, - {"_fsm_exec", nil, &__fsm_exec}, {"_get_by_path", nil, &__get_by_path}, {"_html_escape", nil, &__html_escape}, {"_i64toa", nil, &__i64toa}, diff --git a/internal/native/recover_arm64_test.tmpl b/internal/native/recover_arm64_test.tmpl new file mode 100644 index 000000000..ba46f6f49 --- /dev/null +++ b/internal/native/recover_arm64_test.tmpl @@ -0,0 +1,668 @@ +/** + * 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 {{PACKAGE}} + +import ( + `os` + `runtime` + `runtime/debug` + `testing` + `time` + `unsafe` + + `github.com/bytedance/sonic/internal/native/types` +) + +var ( + debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == "" +) + +func TestMain(m *testing.M) { + go func () { + if !debugAsyncGC { + return + } + println("Begin GC looping...") + for { + runtime.GC() + debug.FreeOSMemory() + } + println("stop GC looping!") + }() + time.Sleep(time.Millisecond*100) + m.Run() +} + +func TestRecover_f64toa(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = f64toa(nil, 123) +} + +func TestRecover_f32toa(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = f32toa(nil, 123) +} + +func TestRecover_i64toa(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = i64toa(nil, 123) +} + +func TestRecover_u64toa(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = u64toa(nil, 123) +} + +func TestRecover_lspace(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = lspace(nil, 2, 0) +} + +func TestRecover_quote(t *testing.T) { + var dn = 10 + var dp = make([]byte, dn) + var sp = []byte("123") + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = quote(nil, 3, unsafe.Pointer(&dp[0]), &dn, 0) + }) + t.Run("dp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = quote(unsafe.Pointer(&sp[0]), 3, nil, &dn, 0) + }) + t.Run("dn", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = quote(unsafe.Pointer(&sp[0]), 3, unsafe.Pointer(&dp[0]), nil, 0) + }) +} + +func TestRecover_html_escape(t *testing.T) { + var dn = 10 + var dp = make([]byte, dn) + var sp = []byte("123") + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = html_escape(nil, 3, unsafe.Pointer(&dp[0]), &dn) + }) + t.Run("dp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = html_escape(unsafe.Pointer(&sp[0]), 3, nil, &dn) + }) + t.Run("dn", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = html_escape(unsafe.Pointer(&sp[0]), 3, unsafe.Pointer(&dp[0]), nil) + }) +} + +func TestRecover_unquote(t *testing.T) { + var ep = 0 + var dp = make([]byte, 10) + var sp = []byte("12\\x\"3\"4") + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = unquote(nil, len(sp), unsafe.Pointer(&dp[0]), &ep, 0) + }) + t.Run("dp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = unquote(unsafe.Pointer(&sp[0]), len(sp), nil, &ep, 0) + }) + t.Run("ep", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = unquote(unsafe.Pointer(&sp[0]), len(sp), unsafe.Pointer(&dp[0]), nil, 0) + }) +} + +func TestRecover_value(t *testing.T) { + var v = new(types.JsonState) + var sp = []byte("123") + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = value(nil, 3, 0, v, 0) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = value(unsafe.Pointer(&sp[0]), 3, 0, nil, 0) + }) +} + +func TestRecover_vstring(t *testing.T) { + var v = new(types.JsonState) + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vstring(nil, &p, v, 0) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vstring(&sp, nil, v, 0) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vstring(&sp, &p, nil, 0) + }) +} + +func TestRecover_vnumber(t *testing.T) { + var v = new(types.JsonState) + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vnumber(nil, &p, v) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vnumber(&sp, nil, v) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vnumber(&sp, &p, nil) + }) +} + +func TestRecover_vsigned(t *testing.T) { + var v = new(types.JsonState) + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vsigned(nil, &p, v) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vsigned(&sp, nil, v) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vsigned(&sp, &p, nil) + }) +} + +func TestRecover_vunsigned(t *testing.T) { + var v = new(types.JsonState) + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vunsigned(nil, &p, v) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vunsigned(&sp, nil, v) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + vunsigned(&sp, &p, nil) + }) +} + +func TestRecover_skip_one(t *testing.T) { + var v = types.NewStateMachine() + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_one(nil, &p, v, 0) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_one(&sp, nil, v, 0) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_one(&sp, &p, nil, 0) + }) +} + +func TestRecover_skip_one_fast(t *testing.T) { + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_one_fast(nil, &p) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_one_fast(&sp, nil) + }) +} + +func TestRecover_skip_array(t *testing.T) { + var v = types.NewStateMachine() + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_array(nil, &p, v, 0) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_array(&sp, nil, v, 0) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_array(&sp, &p, nil, 0) + }) +} + +func TestRecover_skip_object(t *testing.T) { + var v = types.NewStateMachine() + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_object(nil, &p, v, 0) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_object(&sp, nil, v, 0) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_object(&sp, &p, nil, 0) + }) +} + +func TestRecover_skip_number(t *testing.T) { + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_number(nil, &p) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = skip_number(&sp, nil) + }) +} + +func TestRecover_get_by_path(t *testing.T) { + var v = []interface{}{} + var sp = "123" + var p = 0 + var m = types.NewStateMachine() + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = get_by_path(nil, &p, &v, m) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = get_by_path(&sp, nil, &v, m) + }) + t.Run("path", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = get_by_path(&sp, &p, nil, m) + }) + t.Run("m", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = get_by_path(&sp, &p, &v, nil) + }) +} + +func TestRecover_validate_one(t *testing.T) { + var v = types.NewStateMachine() + var sp = "123" + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_one(nil, &p, v) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_one(&sp, nil, v) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_one(&sp, &p, nil) + }) +} + +func TestRecover_validate_utf8(t *testing.T) { + var v = types.NewStateMachine() + var sp = string([]byte{0xff, 0xff, 0xff}) + var p = 0 + t.Run("sp", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_utf8(nil, &p, v) + }) + t.Run("p", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_utf8(&sp, nil, v) + }) + t.Run("v", func(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_utf8(&sp, &p, nil) + }) +} + +func TestRecover_validate_utf8_fast(t *testing.T) { + defer func() { + if r := recover(); r!= nil { + t.Log("recover: ", r) + } else { + t.Fatal("no panic") + } + }() + _ = validate_utf8_fast(nil) +} diff --git a/native/arm/atof_eisel_lemire.h b/native/arm/atof_eisel_lemire.h new file mode 100644 index 000000000..ee4f02bb4 --- /dev/null +++ b/native/arm/atof_eisel_lemire.h @@ -0,0 +1,856 @@ +/* + * 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. + * + * Copyright (c) Daniel Lemire + * + * Boost Software License - Version 1.0 - August 17th, 2003 + * + * Permission is hereby granted, free of charge, to any person or organization + * obtaining a copy of the software and accompanying documentation covered by + * this license (the "Software") to use, reproduce, display, distribute, + * execute, and transmit the Software, and to prepare derivative works of the + * Software, and to permit third-parties to whom the Software is furnished to + * do so, all subject to the following: + * + * The copyright notices in the Software and this entire statement, including + * the above license grant, this restriction and the following disclaimer, + * must be included in all copies of the Software, in whole or in part, and + * all derivative works of the Software, unless such copies or derivative + * works are solely in the form of machine-executable object code generated by + * a source language processor. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT + * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE + * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * This file may have been modified by ByteDance authors. All ByteDance + * Modifications are Copyright 2022 ByteDance Authors. + */ + +#pragma once + +#include "native.h" + +/* two uint64_t represent a 128-bit unsigned integer */ +typedef struct u128_output { + uint64_t hi; + uint64_t lo; +} u128_output; + +static const uint64_t POW10_M128_TAB[697][2]; + +static always_inline int count_leading_zeroes_u64(uint64_t u) { + return u ? __builtin_clzl(u) : 64; +} + +static always_inline u128_output mul_u64(uint64_t x, uint64_t y) { + u128_output ret; + __uint128_t z = ((__uint128_t)x) * ((__uint128_t)y); + ret.hi = (uint64_t)(z >> 64); + ret.lo = (uint64_t)z; + return ret; +} + +/* This is Eisel Lemire ParseFloat algorithm implemented in C. + * reference: https://nigeltao.github.io/blog/2020/eisel-lemire.html + */ +static INLINE_FOR_ARM bool atof_eisel_lemire64_1(uint64_t mant, int exp10, int sgn, double *val) { + if (exp10 < -348 || exp10 > 347) { + return false; + } + + /* Calculate the 2-base exponent of float */ + int clz = count_leading_zeroes_u64(mant); + mant <<= clz; + /* lg10/lg2 ≈ 217706>>16 */ + uint64_t ret_exp2 = ((uint64_t)((217706 * exp10) >> 16) + 64 + 1023) - ((uint64_t)clz); + + /* Calculate the mantissa of float */ + u128_output x = mul_u64(mant, POW10_M128_TAB[exp10 + 348][1]); // higher 64 bits of POW10 mantissa + uint64_t x_hi = x.hi; + uint64_t x_lo = x.lo; + + /* Wider approximation for the float. + * mant * PWO10_M * exp2 <= ret float < mant * (PWO10_M + 1) * exp2. + * mant * PWO10_M <= ret_man < mant * (PWO10_M + 1) + * If the lower 9 bits of x_hi is 0x1FF and the mant + x_lo is overflow， + * x_hi needs to add 1 for the upper bound, and it is ambiguous for higher 54 bits of ret_man. + */ + if ((x_hi & 0x1FF) == 0x1FF && (x_lo + mant) < mant) { + /* lower 64 bits of POW10 mantissa */ + u128_output y = mul_u64(mant, POW10_M128_TAB[exp10 + 348][0]); + uint64_t merged_hi = x_hi; + uint64_t merged_lo = x_lo + y.hi; + + /* lower 64 bits of multiply output overflow */ + if (merged_lo < x_lo) { + merged_hi ++; + } + + /* Still ambigunous */ + if ((merged_hi & 0x1FF) == 0x1FF && (merged_lo + 1) == 0 && (y.lo + mant) < mant) { + return false; + } + + x_hi = merged_hi; + x_lo = merged_lo; + } + + /* Remain 54 bits */ + int msb = x_hi >> 63; + uint64_t ret_man = x_hi >> (msb + 9); + ret_exp2 -= 1 ^ msb; + + /* Half-way Ambiguity */ + if ((x_lo == 0) && ((x_hi & 0x1FF) == 0) && ((ret_man & 3) == 1)) { + return false; + } + + /* If not half-way, then it's rounding to-nearest + * Remain 53 bits. + */ + ret_man += ret_man & 1; + ret_man >>= 1; + /* If rounding overflowed, shift again */ + if ((ret_man >> 53) > 0) { + ret_man >>= 1; + ret_exp2 += 1; + } + + /* ret_exp2 < 0 means subnormal double. + * ret_exp2 >= 0x7FF means INF/inf. + */ + if ((ret_exp2 - 1) >= (0x7FF - 1)) { + return false; + } + + /* Get the lower 52 bits as finnal mantissa */ + uint64_t bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFF); + if (sgn == -1) { + bits |= 1ull << 63; + } + *(int64_t*)val = bits; + + return true; +} + +/* Including 128-bit mantissa approximations (rounded down) of the powers of 10. + * For example: + * 1e-348 ≈ 0xFA8FD5A0081C0288_1732C869CD60E453 * (2 ** (-348 * lg10 / lg2 - 127)). + * 1e-348 ≈ 0xFA8FD5A0081C0288 * (2 ** (-348 * lg10 / lg2 - 63)). + * lg10/lg2 ≈ 217706.0/65536.0. + */ +static const uint64_t POW10_M128_TAB[697][2] = { + {0x1732C869CD60E453, 0xFA8FD5A0081C0288}, // 1e-348 + {0x0E7FBD42205C8EB4, 0x9C99E58405118195}, // 1e-347 + {0x521FAC92A873B261, 0xC3C05EE50655E1FA}, // 1e-346 + {0xE6A797B752909EF9, 0xF4B0769E47EB5A78}, // 1e-345 + {0x9028BED2939A635C, 0x98EE4A22ECF3188B}, // 1e-344 + {0x7432EE873880FC33, 0xBF29DCABA82FDEAE}, // 1e-343 + {0x113FAA2906A13B3F, 0xEEF453D6923BD65A}, // 1e-342 + {0x4AC7CA59A424C507, 0x9558B4661B6565F8}, // 1e-341 + {0x5D79BCF00D2DF649, 0xBAAEE17FA23EBF76}, // 1e-340 + {0xF4D82C2C107973DC, 0xE95A99DF8ACE6F53}, // 1e-339 + {0x79071B9B8A4BE869, 0x91D8A02BB6C10594}, // 1e-338 + {0x9748E2826CDEE284, 0xB64EC836A47146F9}, // 1e-337 + {0xFD1B1B2308169B25, 0xE3E27A444D8D98B7}, // 1e-336 + {0xFE30F0F5E50E20F7, 0x8E6D8C6AB0787F72}, // 1e-335 + {0xBDBD2D335E51A935, 0xB208EF855C969F4F}, // 1e-334 + {0xAD2C788035E61382, 0xDE8B2B66B3BC4723}, // 1e-333 + {0x4C3BCB5021AFCC31, 0x8B16FB203055AC76}, // 1e-332 + {0xDF4ABE242A1BBF3D, 0xADDCB9E83C6B1793}, // 1e-331 + {0xD71D6DAD34A2AF0D, 0xD953E8624B85DD78}, // 1e-330 + {0x8672648C40E5AD68, 0x87D4713D6F33AA6B}, // 1e-329 + {0x680EFDAF511F18C2, 0xA9C98D8CCB009506}, // 1e-328 + {0x0212BD1B2566DEF2, 0xD43BF0EFFDC0BA48}, // 1e-327 + {0x014BB630F7604B57, 0x84A57695FE98746D}, // 1e-326 + {0x419EA3BD35385E2D, 0xA5CED43B7E3E9188}, // 1e-325 + {0x52064CAC828675B9, 0xCF42894A5DCE35EA}, // 1e-324 + {0x7343EFEBD1940993, 0x818995CE7AA0E1B2}, // 1e-323 + {0x1014EBE6C5F90BF8, 0xA1EBFB4219491A1F}, // 1e-322 + {0xD41A26E077774EF6, 0xCA66FA129F9B60A6}, // 1e-321 + {0x8920B098955522B4, 0xFD00B897478238D0}, // 1e-320 + {0x55B46E5F5D5535B0, 0x9E20735E8CB16382}, // 1e-319 + {0xEB2189F734AA831D, 0xC5A890362FDDBC62}, // 1e-318 + {0xA5E9EC7501D523E4, 0xF712B443BBD52B7B}, // 1e-317 + {0x47B233C92125366E, 0x9A6BB0AA55653B2D}, // 1e-316 + {0x999EC0BB696E840A, 0xC1069CD4EABE89F8}, // 1e-315 + {0xC00670EA43CA250D, 0xF148440A256E2C76}, // 1e-314 + {0x380406926A5E5728, 0x96CD2A865764DBCA}, // 1e-313 + {0xC605083704F5ECF2, 0xBC807527ED3E12BC}, // 1e-312 + {0xF7864A44C633682E, 0xEBA09271E88D976B}, // 1e-311 + {0x7AB3EE6AFBE0211D, 0x93445B8731587EA3}, // 1e-310 + {0x5960EA05BAD82964, 0xB8157268FDAE9E4C}, // 1e-309 + {0x6FB92487298E33BD, 0xE61ACF033D1A45DF}, // 1e-308 + {0xA5D3B6D479F8E056, 0x8FD0C16206306BAB}, // 1e-307 + {0x8F48A4899877186C, 0xB3C4F1BA87BC8696}, // 1e-306 + {0x331ACDABFE94DE87, 0xE0B62E2929ABA83C}, // 1e-305 + {0x9FF0C08B7F1D0B14, 0x8C71DCD9BA0B4925}, // 1e-304 + {0x07ECF0AE5EE44DD9, 0xAF8E5410288E1B6F}, // 1e-303 + {0xC9E82CD9F69D6150, 0xDB71E91432B1A24A}, // 1e-302 + {0xBE311C083A225CD2, 0x892731AC9FAF056E}, // 1e-301 + {0x6DBD630A48AAF406, 0xAB70FE17C79AC6CA}, // 1e-300 + {0x092CBBCCDAD5B108, 0xD64D3D9DB981787D}, // 1e-299 + {0x25BBF56008C58EA5, 0x85F0468293F0EB4E}, // 1e-298 + {0xAF2AF2B80AF6F24E, 0xA76C582338ED2621}, // 1e-297 + {0x1AF5AF660DB4AEE1, 0xD1476E2C07286FAA}, // 1e-296 + {0x50D98D9FC890ED4D, 0x82CCA4DB847945CA}, // 1e-295 + {0xE50FF107BAB528A0, 0xA37FCE126597973C}, // 1e-294 + {0x1E53ED49A96272C8, 0xCC5FC196FEFD7D0C}, // 1e-293 + {0x25E8E89C13BB0F7A, 0xFF77B1FCBEBCDC4F}, // 1e-292 + {0x77B191618C54E9AC, 0x9FAACF3DF73609B1}, // 1e-291 + {0xD59DF5B9EF6A2417, 0xC795830D75038C1D}, // 1e-290 + {0x4B0573286B44AD1D, 0xF97AE3D0D2446F25}, // 1e-289 + {0x4EE367F9430AEC32, 0x9BECCE62836AC577}, // 1e-288 + {0x229C41F793CDA73F, 0xC2E801FB244576D5}, // 1e-287 + {0x6B43527578C1110F, 0xF3A20279ED56D48A}, // 1e-286 + {0x830A13896B78AAA9, 0x9845418C345644D6}, // 1e-285 + {0x23CC986BC656D553, 0xBE5691EF416BD60C}, // 1e-284 + {0x2CBFBE86B7EC8AA8, 0xEDEC366B11C6CB8F}, // 1e-283 + {0x7BF7D71432F3D6A9, 0x94B3A202EB1C3F39}, // 1e-282 + {0xDAF5CCD93FB0CC53, 0xB9E08A83A5E34F07}, // 1e-281 + {0xD1B3400F8F9CFF68, 0xE858AD248F5C22C9}, // 1e-280 + {0x23100809B9C21FA1, 0x91376C36D99995BE}, // 1e-279 + {0xABD40A0C2832A78A, 0xB58547448FFFFB2D}, // 1e-278 + {0x16C90C8F323F516C, 0xE2E69915B3FFF9F9}, // 1e-277 + {0xAE3DA7D97F6792E3, 0x8DD01FAD907FFC3B}, // 1e-276 + {0x99CD11CFDF41779C, 0xB1442798F49FFB4A}, // 1e-275 + {0x40405643D711D583, 0xDD95317F31C7FA1D}, // 1e-274 + {0x482835EA666B2572, 0x8A7D3EEF7F1CFC52}, // 1e-273 + {0xDA3243650005EECF, 0xAD1C8EAB5EE43B66}, // 1e-272 + {0x90BED43E40076A82, 0xD863B256369D4A40}, // 1e-271 + {0x5A7744A6E804A291, 0x873E4F75E2224E68}, // 1e-270 + {0x711515D0A205CB36, 0xA90DE3535AAAE202}, // 1e-269 + {0x0D5A5B44CA873E03, 0xD3515C2831559A83}, // 1e-268 + {0xE858790AFE9486C2, 0x8412D9991ED58091}, // 1e-267 + {0x626E974DBE39A872, 0xA5178FFF668AE0B6}, // 1e-266 + {0xFB0A3D212DC8128F, 0xCE5D73FF402D98E3}, // 1e-265 + {0x7CE66634BC9D0B99, 0x80FA687F881C7F8E}, // 1e-264 + {0x1C1FFFC1EBC44E80, 0xA139029F6A239F72}, // 1e-263 + {0xA327FFB266B56220, 0xC987434744AC874E}, // 1e-262 + {0x4BF1FF9F0062BAA8, 0xFBE9141915D7A922}, // 1e-261 + {0x6F773FC3603DB4A9, 0x9D71AC8FADA6C9B5}, // 1e-260 + {0xCB550FB4384D21D3, 0xC4CE17B399107C22}, // 1e-259 + {0x7E2A53A146606A48, 0xF6019DA07F549B2B}, // 1e-258 + {0x2EDA7444CBFC426D, 0x99C102844F94E0FB}, // 1e-257 + {0xFA911155FEFB5308, 0xC0314325637A1939}, // 1e-256 + {0x793555AB7EBA27CA, 0xF03D93EEBC589F88}, // 1e-255 + {0x4BC1558B2F3458DE, 0x96267C7535B763B5}, // 1e-254 + {0x9EB1AAEDFB016F16, 0xBBB01B9283253CA2}, // 1e-253 + {0x465E15A979C1CADC, 0xEA9C227723EE8BCB}, // 1e-252 + {0x0BFACD89EC191EC9, 0x92A1958A7675175F}, // 1e-251 + {0xCEF980EC671F667B, 0xB749FAED14125D36}, // 1e-250 + {0x82B7E12780E7401A, 0xE51C79A85916F484}, // 1e-249 + {0xD1B2ECB8B0908810, 0x8F31CC0937AE58D2}, // 1e-248 + {0x861FA7E6DCB4AA15, 0xB2FE3F0B8599EF07}, // 1e-247 + {0x67A791E093E1D49A, 0xDFBDCECE67006AC9}, // 1e-246 + {0xE0C8BB2C5C6D24E0, 0x8BD6A141006042BD}, // 1e-245 + {0x58FAE9F773886E18, 0xAECC49914078536D}, // 1e-244 + {0xAF39A475506A899E, 0xDA7F5BF590966848}, // 1e-243 + {0x6D8406C952429603, 0x888F99797A5E012D}, // 1e-242 + {0xC8E5087BA6D33B83, 0xAAB37FD7D8F58178}, // 1e-241 + {0xFB1E4A9A90880A64, 0xD5605FCDCF32E1D6}, // 1e-240 + {0x5CF2EEA09A55067F, 0x855C3BE0A17FCD26}, // 1e-239 + {0xF42FAA48C0EA481E, 0xA6B34AD8C9DFC06F}, // 1e-238 + {0xF13B94DAF124DA26, 0xD0601D8EFC57B08B}, // 1e-237 + {0x76C53D08D6B70858, 0x823C12795DB6CE57}, // 1e-236 + {0x54768C4B0C64CA6E, 0xA2CB1717B52481ED}, // 1e-235 + {0xA9942F5DCF7DFD09, 0xCB7DDCDDA26DA268}, // 1e-234 + {0xD3F93B35435D7C4C, 0xFE5D54150B090B02}, // 1e-233 + {0xC47BC5014A1A6DAF, 0x9EFA548D26E5A6E1}, // 1e-232 + {0x359AB6419CA1091B, 0xC6B8E9B0709F109A}, // 1e-231 + {0xC30163D203C94B62, 0xF867241C8CC6D4C0}, // 1e-230 + {0x79E0DE63425DCF1D, 0x9B407691D7FC44F8}, // 1e-229 + {0x985915FC12F542E4, 0xC21094364DFB5636}, // 1e-228 + {0x3E6F5B7B17B2939D, 0xF294B943E17A2BC4}, // 1e-227 + {0xA705992CEECF9C42, 0x979CF3CA6CEC5B5A}, // 1e-226 + {0x50C6FF782A838353, 0xBD8430BD08277231}, // 1e-225 + {0xA4F8BF5635246428, 0xECE53CEC4A314EBD}, // 1e-224 + {0x871B7795E136BE99, 0x940F4613AE5ED136}, // 1e-223 + {0x28E2557B59846E3F, 0xB913179899F68584}, // 1e-222 + {0x331AEADA2FE589CF, 0xE757DD7EC07426E5}, // 1e-221 + {0x3FF0D2C85DEF7621, 0x9096EA6F3848984F}, // 1e-220 + {0x0FED077A756B53A9, 0xB4BCA50B065ABE63}, // 1e-219 + {0xD3E8495912C62894, 0xE1EBCE4DC7F16DFB}, // 1e-218 + {0x64712DD7ABBBD95C, 0x8D3360F09CF6E4BD}, // 1e-217 + {0xBD8D794D96AACFB3, 0xB080392CC4349DEC}, // 1e-216 + {0xECF0D7A0FC5583A0, 0xDCA04777F541C567}, // 1e-215 + {0xF41686C49DB57244, 0x89E42CAAF9491B60}, // 1e-214 + {0x311C2875C522CED5, 0xAC5D37D5B79B6239}, // 1e-213 + {0x7D633293366B828B, 0xD77485CB25823AC7}, // 1e-212 + {0xAE5DFF9C02033197, 0x86A8D39EF77164BC}, // 1e-211 + {0xD9F57F830283FDFC, 0xA8530886B54DBDEB}, // 1e-210 + {0xD072DF63C324FD7B, 0xD267CAA862A12D66}, // 1e-209 + {0x4247CB9E59F71E6D, 0x8380DEA93DA4BC60}, // 1e-208 + {0x52D9BE85F074E608, 0xA46116538D0DEB78}, // 1e-207 + {0x67902E276C921F8B, 0xCD795BE870516656}, // 1e-206 + {0x00BA1CD8A3DB53B6, 0x806BD9714632DFF6}, // 1e-205 + {0x80E8A40ECCD228A4, 0xA086CFCD97BF97F3}, // 1e-204 + {0x6122CD128006B2CD, 0xC8A883C0FDAF7DF0}, // 1e-203 + {0x796B805720085F81, 0xFAD2A4B13D1B5D6C}, // 1e-202 + {0xCBE3303674053BB0, 0x9CC3A6EEC6311A63}, // 1e-201 + {0xBEDBFC4411068A9C, 0xC3F490AA77BD60FC}, // 1e-200 + {0xEE92FB5515482D44, 0xF4F1B4D515ACB93B}, // 1e-199 + {0x751BDD152D4D1C4A, 0x991711052D8BF3C5}, // 1e-198 + {0xD262D45A78A0635D, 0xBF5CD54678EEF0B6}, // 1e-197 + {0x86FB897116C87C34, 0xEF340A98172AACE4}, // 1e-196 + {0xD45D35E6AE3D4DA0, 0x9580869F0E7AAC0E}, // 1e-195 + {0x8974836059CCA109, 0xBAE0A846D2195712}, // 1e-194 + {0x2BD1A438703FC94B, 0xE998D258869FACD7}, // 1e-193 + {0x7B6306A34627DDCF, 0x91FF83775423CC06}, // 1e-192 + {0x1A3BC84C17B1D542, 0xB67F6455292CBF08}, // 1e-191 + {0x20CABA5F1D9E4A93, 0xE41F3D6A7377EECA}, // 1e-190 + {0x547EB47B7282EE9C, 0x8E938662882AF53E}, // 1e-189 + {0xE99E619A4F23AA43, 0xB23867FB2A35B28D}, // 1e-188 + {0x6405FA00E2EC94D4, 0xDEC681F9F4C31F31}, // 1e-187 + {0xDE83BC408DD3DD04, 0x8B3C113C38F9F37E}, // 1e-186 + {0x9624AB50B148D445, 0xAE0B158B4738705E}, // 1e-185 + {0x3BADD624DD9B0957, 0xD98DDAEE19068C76}, // 1e-184 + {0xE54CA5D70A80E5D6, 0x87F8A8D4CFA417C9}, // 1e-183 + {0x5E9FCF4CCD211F4C, 0xA9F6D30A038D1DBC}, // 1e-182 + {0x7647C3200069671F, 0xD47487CC8470652B}, // 1e-181 + {0x29ECD9F40041E073, 0x84C8D4DFD2C63F3B}, // 1e-180 + {0xF468107100525890, 0xA5FB0A17C777CF09}, // 1e-179 + {0x7182148D4066EEB4, 0xCF79CC9DB955C2CC}, // 1e-178 + {0xC6F14CD848405530, 0x81AC1FE293D599BF}, // 1e-177 + {0xB8ADA00E5A506A7C, 0xA21727DB38CB002F}, // 1e-176 + {0xA6D90811F0E4851C, 0xCA9CF1D206FDC03B}, // 1e-175 + {0x908F4A166D1DA663, 0xFD442E4688BD304A}, // 1e-174 + {0x9A598E4E043287FE, 0x9E4A9CEC15763E2E}, // 1e-173 + {0x40EFF1E1853F29FD, 0xC5DD44271AD3CDBA}, // 1e-172 + {0xD12BEE59E68EF47C, 0xF7549530E188C128}, // 1e-171 + {0x82BB74F8301958CE, 0x9A94DD3E8CF578B9}, // 1e-170 + {0xE36A52363C1FAF01, 0xC13A148E3032D6E7}, // 1e-169 + {0xDC44E6C3CB279AC1, 0xF18899B1BC3F8CA1}, // 1e-168 + {0x29AB103A5EF8C0B9, 0x96F5600F15A7B7E5}, // 1e-167 + {0x7415D448F6B6F0E7, 0xBCB2B812DB11A5DE}, // 1e-166 + {0x111B495B3464AD21, 0xEBDF661791D60F56}, // 1e-165 + {0xCAB10DD900BEEC34, 0x936B9FCEBB25C995}, // 1e-164 + {0x3D5D514F40EEA742, 0xB84687C269EF3BFB}, // 1e-163 + {0x0CB4A5A3112A5112, 0xE65829B3046B0AFA}, // 1e-162 + {0x47F0E785EABA72AB, 0x8FF71A0FE2C2E6DC}, // 1e-161 + {0x59ED216765690F56, 0xB3F4E093DB73A093}, // 1e-160 + {0x306869C13EC3532C, 0xE0F218B8D25088B8}, // 1e-159 + {0x1E414218C73A13FB, 0x8C974F7383725573}, // 1e-158 + {0xE5D1929EF90898FA, 0xAFBD2350644EEACF}, // 1e-157 + {0xDF45F746B74ABF39, 0xDBAC6C247D62A583}, // 1e-156 + {0x6B8BBA8C328EB783, 0x894BC396CE5DA772}, // 1e-155 + {0x066EA92F3F326564, 0xAB9EB47C81F5114F}, // 1e-154 + {0xC80A537B0EFEFEBD, 0xD686619BA27255A2}, // 1e-153 + {0xBD06742CE95F5F36, 0x8613FD0145877585}, // 1e-152 + {0x2C48113823B73704, 0xA798FC4196E952E7}, // 1e-151 + {0xF75A15862CA504C5, 0xD17F3B51FCA3A7A0}, // 1e-150 + {0x9A984D73DBE722FB, 0x82EF85133DE648C4}, // 1e-149 + {0xC13E60D0D2E0EBBA, 0xA3AB66580D5FDAF5}, // 1e-148 + {0x318DF905079926A8, 0xCC963FEE10B7D1B3}, // 1e-147 + {0xFDF17746497F7052, 0xFFBBCFE994E5C61F}, // 1e-146 + {0xFEB6EA8BEDEFA633, 0x9FD561F1FD0F9BD3}, // 1e-145 + {0xFE64A52EE96B8FC0, 0xC7CABA6E7C5382C8}, // 1e-144 + {0x3DFDCE7AA3C673B0, 0xF9BD690A1B68637B}, // 1e-143 + {0x06BEA10CA65C084E, 0x9C1661A651213E2D}, // 1e-142 + {0x486E494FCFF30A62, 0xC31BFA0FE5698DB8}, // 1e-141 + {0x5A89DBA3C3EFCCFA, 0xF3E2F893DEC3F126}, // 1e-140 + {0xF89629465A75E01C, 0x986DDB5C6B3A76B7}, // 1e-139 + {0xF6BBB397F1135823, 0xBE89523386091465}, // 1e-138 + {0x746AA07DED582E2C, 0xEE2BA6C0678B597F}, // 1e-137 + {0xA8C2A44EB4571CDC, 0x94DB483840B717EF}, // 1e-136 + {0x92F34D62616CE413, 0xBA121A4650E4DDEB}, // 1e-135 + {0x77B020BAF9C81D17, 0xE896A0D7E51E1566}, // 1e-134 + {0x0ACE1474DC1D122E, 0x915E2486EF32CD60}, // 1e-133 + {0x0D819992132456BA, 0xB5B5ADA8AAFF80B8}, // 1e-132 + {0x10E1FFF697ED6C69, 0xE3231912D5BF60E6}, // 1e-131 + {0xCA8D3FFA1EF463C1, 0x8DF5EFABC5979C8F}, // 1e-130 + {0xBD308FF8A6B17CB2, 0xB1736B96B6FD83B3}, // 1e-129 + {0xAC7CB3F6D05DDBDE, 0xDDD0467C64BCE4A0}, // 1e-128 + {0x6BCDF07A423AA96B, 0x8AA22C0DBEF60EE4}, // 1e-127 + {0x86C16C98D2C953C6, 0xAD4AB7112EB3929D}, // 1e-126 + {0xE871C7BF077BA8B7, 0xD89D64D57A607744}, // 1e-125 + {0x11471CD764AD4972, 0x87625F056C7C4A8B}, // 1e-124 + {0xD598E40D3DD89BCF, 0xA93AF6C6C79B5D2D}, // 1e-123 + {0x4AFF1D108D4EC2C3, 0xD389B47879823479}, // 1e-122 + {0xCEDF722A585139BA, 0x843610CB4BF160CB}, // 1e-121 + {0xC2974EB4EE658828, 0xA54394FE1EEDB8FE}, // 1e-120 + {0x733D226229FEEA32, 0xCE947A3DA6A9273E}, // 1e-119 + {0x0806357D5A3F525F, 0x811CCC668829B887}, // 1e-118 + {0xCA07C2DCB0CF26F7, 0xA163FF802A3426A8}, // 1e-117 + {0xFC89B393DD02F0B5, 0xC9BCFF6034C13052}, // 1e-116 + {0xBBAC2078D443ACE2, 0xFC2C3F3841F17C67}, // 1e-115 + {0xD54B944B84AA4C0D, 0x9D9BA7832936EDC0}, // 1e-114 + {0x0A9E795E65D4DF11, 0xC5029163F384A931}, // 1e-113 + {0x4D4617B5FF4A16D5, 0xF64335BCF065D37D}, // 1e-112 + {0x504BCED1BF8E4E45, 0x99EA0196163FA42E}, // 1e-111 + {0xE45EC2862F71E1D6, 0xC06481FB9BCF8D39}, // 1e-110 + {0x5D767327BB4E5A4C, 0xF07DA27A82C37088}, // 1e-109 + {0x3A6A07F8D510F86F, 0x964E858C91BA2655}, // 1e-108 + {0x890489F70A55368B, 0xBBE226EFB628AFEA}, // 1e-107 + {0x2B45AC74CCEA842E, 0xEADAB0ABA3B2DBE5}, // 1e-106 + {0x3B0B8BC90012929D, 0x92C8AE6B464FC96F}, // 1e-105 + {0x09CE6EBB40173744, 0xB77ADA0617E3BBCB}, // 1e-104 + {0xCC420A6A101D0515, 0xE55990879DDCAABD}, // 1e-103 + {0x9FA946824A12232D, 0x8F57FA54C2A9EAB6}, // 1e-102 + {0x47939822DC96ABF9, 0xB32DF8E9F3546564}, // 1e-101 + {0x59787E2B93BC56F7, 0xDFF9772470297EBD}, // 1e-100 + {0x57EB4EDB3C55B65A, 0x8BFBEA76C619EF36}, // 1e-99 + {0xEDE622920B6B23F1, 0xAEFAE51477A06B03}, // 1e-98 + {0xE95FAB368E45ECED, 0xDAB99E59958885C4}, // 1e-97 + {0x11DBCB0218EBB414, 0x88B402F7FD75539B}, // 1e-96 + {0xD652BDC29F26A119, 0xAAE103B5FCD2A881}, // 1e-95 + {0x4BE76D3346F0495F, 0xD59944A37C0752A2}, // 1e-94 + {0x6F70A4400C562DDB, 0x857FCAE62D8493A5}, // 1e-93 + {0xCB4CCD500F6BB952, 0xA6DFBD9FB8E5B88E}, // 1e-92 + {0x7E2000A41346A7A7, 0xD097AD07A71F26B2}, // 1e-91 + {0x8ED400668C0C28C8, 0x825ECC24C873782F}, // 1e-90 + {0x728900802F0F32FA, 0xA2F67F2DFA90563B}, // 1e-89 + {0x4F2B40A03AD2FFB9, 0xCBB41EF979346BCA}, // 1e-88 + {0xE2F610C84987BFA8, 0xFEA126B7D78186BC}, // 1e-87 + {0x0DD9CA7D2DF4D7C9, 0x9F24B832E6B0F436}, // 1e-86 + {0x91503D1C79720DBB, 0xC6EDE63FA05D3143}, // 1e-85 + {0x75A44C6397CE912A, 0xF8A95FCF88747D94}, // 1e-84 + {0xC986AFBE3EE11ABA, 0x9B69DBE1B548CE7C}, // 1e-83 + {0xFBE85BADCE996168, 0xC24452DA229B021B}, // 1e-82 + {0xFAE27299423FB9C3, 0xF2D56790AB41C2A2}, // 1e-81 + {0xDCCD879FC967D41A, 0x97C560BA6B0919A5}, // 1e-80 + {0x5400E987BBC1C920, 0xBDB6B8E905CB600F}, // 1e-79 + {0x290123E9AAB23B68, 0xED246723473E3813}, // 1e-78 + {0xF9A0B6720AAF6521, 0x9436C0760C86E30B}, // 1e-77 + {0xF808E40E8D5B3E69, 0xB94470938FA89BCE}, // 1e-76 + {0xB60B1D1230B20E04, 0xE7958CB87392C2C2}, // 1e-75 + {0xB1C6F22B5E6F48C2, 0x90BD77F3483BB9B9}, // 1e-74 + {0x1E38AEB6360B1AF3, 0xB4ECD5F01A4AA828}, // 1e-73 + {0x25C6DA63C38DE1B0, 0xE2280B6C20DD5232}, // 1e-72 + {0x579C487E5A38AD0E, 0x8D590723948A535F}, // 1e-71 + {0x2D835A9DF0C6D851, 0xB0AF48EC79ACE837}, // 1e-70 + {0xF8E431456CF88E65, 0xDCDB1B2798182244}, // 1e-69 + {0x1B8E9ECB641B58FF, 0x8A08F0F8BF0F156B}, // 1e-68 + {0xE272467E3D222F3F, 0xAC8B2D36EED2DAC5}, // 1e-67 + {0x5B0ED81DCC6ABB0F, 0xD7ADF884AA879177}, // 1e-66 + {0x98E947129FC2B4E9, 0x86CCBB52EA94BAEA}, // 1e-65 + {0x3F2398D747B36224, 0xA87FEA27A539E9A5}, // 1e-64 + {0x8EEC7F0D19A03AAD, 0xD29FE4B18E88640E}, // 1e-63 + {0x1953CF68300424AC, 0x83A3EEEEF9153E89}, // 1e-62 + {0x5FA8C3423C052DD7, 0xA48CEAAAB75A8E2B}, // 1e-61 + {0x3792F412CB06794D, 0xCDB02555653131B6}, // 1e-60 + {0xE2BBD88BBEE40BD0, 0x808E17555F3EBF11}, // 1e-59 + {0x5B6ACEAEAE9D0EC4, 0xA0B19D2AB70E6ED6}, // 1e-58 + {0xF245825A5A445275, 0xC8DE047564D20A8B}, // 1e-57 + {0xEED6E2F0F0D56712, 0xFB158592BE068D2E}, // 1e-56 + {0x55464DD69685606B, 0x9CED737BB6C4183D}, // 1e-55 + {0xAA97E14C3C26B886, 0xC428D05AA4751E4C}, // 1e-54 + {0xD53DD99F4B3066A8, 0xF53304714D9265DF}, // 1e-53 + {0xE546A8038EFE4029, 0x993FE2C6D07B7FAB}, // 1e-52 + {0xDE98520472BDD033, 0xBF8FDB78849A5F96}, // 1e-51 + {0x963E66858F6D4440, 0xEF73D256A5C0F77C}, // 1e-50 + {0xDDE7001379A44AA8, 0x95A8637627989AAD}, // 1e-49 + {0x5560C018580D5D52, 0xBB127C53B17EC159}, // 1e-48 + {0xAAB8F01E6E10B4A6, 0xE9D71B689DDE71AF}, // 1e-47 + {0xCAB3961304CA70E8, 0x9226712162AB070D}, // 1e-46 + {0x3D607B97C5FD0D22, 0xB6B00D69BB55C8D1}, // 1e-45 + {0x8CB89A7DB77C506A, 0xE45C10C42A2B3B05}, // 1e-44 + {0x77F3608E92ADB242, 0x8EB98A7A9A5B04E3}, // 1e-43 + {0x55F038B237591ED3, 0xB267ED1940F1C61C}, // 1e-42 + {0x6B6C46DEC52F6688, 0xDF01E85F912E37A3}, // 1e-41 + {0x2323AC4B3B3DA015, 0x8B61313BBABCE2C6}, // 1e-40 + {0xABEC975E0A0D081A, 0xAE397D8AA96C1B77}, // 1e-39 + {0x96E7BD358C904A21, 0xD9C7DCED53C72255}, // 1e-38 + {0x7E50D64177DA2E54, 0x881CEA14545C7575}, // 1e-37 + {0xDDE50BD1D5D0B9E9, 0xAA242499697392D2}, // 1e-36 + {0x955E4EC64B44E864, 0xD4AD2DBFC3D07787}, // 1e-35 + {0xBD5AF13BEF0B113E, 0x84EC3C97DA624AB4}, // 1e-34 + {0xECB1AD8AEACDD58E, 0xA6274BBDD0FADD61}, // 1e-33 + {0x67DE18EDA5814AF2, 0xCFB11EAD453994BA}, // 1e-32 + {0x80EACF948770CED7, 0x81CEB32C4B43FCF4}, // 1e-31 + {0xA1258379A94D028D, 0xA2425FF75E14FC31}, // 1e-30 + {0x096EE45813A04330, 0xCAD2F7F5359A3B3E}, // 1e-29 + {0x8BCA9D6E188853FC, 0xFD87B5F28300CA0D}, // 1e-28 + {0x775EA264CF55347D, 0x9E74D1B791E07E48}, // 1e-27 + {0x95364AFE032A819D, 0xC612062576589DDA}, // 1e-26 + {0x3A83DDBD83F52204, 0xF79687AED3EEC551}, // 1e-25 + {0xC4926A9672793542, 0x9ABE14CD44753B52}, // 1e-24 + {0x75B7053C0F178293, 0xC16D9A0095928A27}, // 1e-23 + {0x5324C68B12DD6338, 0xF1C90080BAF72CB1}, // 1e-22 + {0xD3F6FC16EBCA5E03, 0x971DA05074DA7BEE}, // 1e-21 + {0x88F4BB1CA6BCF584, 0xBCE5086492111AEA}, // 1e-20 + {0x2B31E9E3D06C32E5, 0xEC1E4A7DB69561A5}, // 1e-19 + {0x3AFF322E62439FCF, 0x9392EE8E921D5D07}, // 1e-18 + {0x09BEFEB9FAD487C2, 0xB877AA3236A4B449}, // 1e-17 + {0x4C2EBE687989A9B3, 0xE69594BEC44DE15B}, // 1e-16 + {0x0F9D37014BF60A10, 0x901D7CF73AB0ACD9}, // 1e-15 + {0x538484C19EF38C94, 0xB424DC35095CD80F}, // 1e-14 + {0x2865A5F206B06FB9, 0xE12E13424BB40E13}, // 1e-13 + {0xF93F87B7442E45D3, 0x8CBCCC096F5088CB}, // 1e-12 + {0xF78F69A51539D748, 0xAFEBFF0BCB24AAFE}, // 1e-11 + {0xB573440E5A884D1B, 0xDBE6FECEBDEDD5BE}, // 1e-10 + {0x31680A88F8953030, 0x89705F4136B4A597}, // 1e-9 + {0xFDC20D2B36BA7C3D, 0xABCC77118461CEFC}, // 1e-8 + {0x3D32907604691B4C, 0xD6BF94D5E57A42BC}, // 1e-7 + {0xA63F9A49C2C1B10F, 0x8637BD05AF6C69B5}, // 1e-6 + {0x0FCF80DC33721D53, 0xA7C5AC471B478423}, // 1e-5 + {0xD3C36113404EA4A8, 0xD1B71758E219652B}, // 1e-4 + {0x645A1CAC083126E9, 0x83126E978D4FDF3B}, // 1e-3 + {0x3D70A3D70A3D70A3, 0xA3D70A3D70A3D70A}, // 1e-2 + {0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC}, // 1e-1 + {0x0000000000000000, 0x8000000000000000}, // 1e0 + {0x0000000000000000, 0xA000000000000000}, // 1e1 + {0x0000000000000000, 0xC800000000000000}, // 1e2 + {0x0000000000000000, 0xFA00000000000000}, // 1e3 + {0x0000000000000000, 0x9C40000000000000}, // 1e4 + {0x0000000000000000, 0xC350000000000000}, // 1e5 + {0x0000000000000000, 0xF424000000000000}, // 1e6 + {0x0000000000000000, 0x9896800000000000}, // 1e7 + {0x0000000000000000, 0xBEBC200000000000}, // 1e8 + {0x0000000000000000, 0xEE6B280000000000}, // 1e9 + {0x0000000000000000, 0x9502F90000000000}, // 1e10 + {0x0000000000000000, 0xBA43B74000000000}, // 1e11 + {0x0000000000000000, 0xE8D4A51000000000}, // 1e12 + {0x0000000000000000, 0x9184E72A00000000}, // 1e13 + {0x0000000000000000, 0xB5E620F480000000}, // 1e14 + {0x0000000000000000, 0xE35FA931A0000000}, // 1e15 + {0x0000000000000000, 0x8E1BC9BF04000000}, // 1e16 + {0x0000000000000000, 0xB1A2BC2EC5000000}, // 1e17 + {0x0000000000000000, 0xDE0B6B3A76400000}, // 1e18 + {0x0000000000000000, 0x8AC7230489E80000}, // 1e19 + {0x0000000000000000, 0xAD78EBC5AC620000}, // 1e20 + {0x0000000000000000, 0xD8D726B7177A8000}, // 1e21 + {0x0000000000000000, 0x878678326EAC9000}, // 1e22 + {0x0000000000000000, 0xA968163F0A57B400}, // 1e23 + {0x0000000000000000, 0xD3C21BCECCEDA100}, // 1e24 + {0x0000000000000000, 0x84595161401484A0}, // 1e25 + {0x0000000000000000, 0xA56FA5B99019A5C8}, // 1e26 + {0x0000000000000000, 0xCECB8F27F4200F3A}, // 1e27 + {0x4000000000000000, 0x813F3978F8940984}, // 1e28 + {0x5000000000000000, 0xA18F07D736B90BE5}, // 1e29 + {0xA400000000000000, 0xC9F2C9CD04674EDE}, // 1e30 + {0x4D00000000000000, 0xFC6F7C4045812296}, // 1e31 + {0xF020000000000000, 0x9DC5ADA82B70B59D}, // 1e32 + {0x6C28000000000000, 0xC5371912364CE305}, // 1e33 + {0xC732000000000000, 0xF684DF56C3E01BC6}, // 1e34 + {0x3C7F400000000000, 0x9A130B963A6C115C}, // 1e35 + {0x4B9F100000000000, 0xC097CE7BC90715B3}, // 1e36 + {0x1E86D40000000000, 0xF0BDC21ABB48DB20}, // 1e37 + {0x1314448000000000, 0x96769950B50D88F4}, // 1e38 + {0x17D955A000000000, 0xBC143FA4E250EB31}, // 1e39 + {0x5DCFAB0800000000, 0xEB194F8E1AE525FD}, // 1e40 + {0x5AA1CAE500000000, 0x92EFD1B8D0CF37BE}, // 1e41 + {0xF14A3D9E40000000, 0xB7ABC627050305AD}, // 1e42 + {0x6D9CCD05D0000000, 0xE596B7B0C643C719}, // 1e43 + {0xE4820023A2000000, 0x8F7E32CE7BEA5C6F}, // 1e44 + {0xDDA2802C8A800000, 0xB35DBF821AE4F38B}, // 1e45 + {0xD50B2037AD200000, 0xE0352F62A19E306E}, // 1e46 + {0x4526F422CC340000, 0x8C213D9DA502DE45}, // 1e47 + {0x9670B12B7F410000, 0xAF298D050E4395D6}, // 1e48 + {0x3C0CDD765F114000, 0xDAF3F04651D47B4C}, // 1e49 + {0xA5880A69FB6AC800, 0x88D8762BF324CD0F}, // 1e50 + {0x8EEA0D047A457A00, 0xAB0E93B6EFEE0053}, // 1e51 + {0x72A4904598D6D880, 0xD5D238A4ABE98068}, // 1e52 + {0x47A6DA2B7F864750, 0x85A36366EB71F041}, // 1e53 + {0x999090B65F67D924, 0xA70C3C40A64E6C51}, // 1e54 + {0xFFF4B4E3F741CF6D, 0xD0CF4B50CFE20765}, // 1e55 + {0xBFF8F10E7A8921A4, 0x82818F1281ED449F}, // 1e56 + {0xAFF72D52192B6A0D, 0xA321F2D7226895C7}, // 1e57 + {0x9BF4F8A69F764490, 0xCBEA6F8CEB02BB39}, // 1e58 + {0x02F236D04753D5B4, 0xFEE50B7025C36A08}, // 1e59 + {0x01D762422C946590, 0x9F4F2726179A2245}, // 1e60 + {0x424D3AD2B7B97EF5, 0xC722F0EF9D80AAD6}, // 1e61 + {0xD2E0898765A7DEB2, 0xF8EBAD2B84E0D58B}, // 1e62 + {0x63CC55F49F88EB2F, 0x9B934C3B330C8577}, // 1e63 + {0x3CBF6B71C76B25FB, 0xC2781F49FFCFA6D5}, // 1e64 + {0x8BEF464E3945EF7A, 0xF316271C7FC3908A}, // 1e65 + {0x97758BF0E3CBB5AC, 0x97EDD871CFDA3A56}, // 1e66 + {0x3D52EEED1CBEA317, 0xBDE94E8E43D0C8EC}, // 1e67 + {0x4CA7AAA863EE4BDD, 0xED63A231D4C4FB27}, // 1e68 + {0x8FE8CAA93E74EF6A, 0x945E455F24FB1CF8}, // 1e69 + {0xB3E2FD538E122B44, 0xB975D6B6EE39E436}, // 1e70 + {0x60DBBCA87196B616, 0xE7D34C64A9C85D44}, // 1e71 + {0xBC8955E946FE31CD, 0x90E40FBEEA1D3A4A}, // 1e72 + {0x6BABAB6398BDBE41, 0xB51D13AEA4A488DD}, // 1e73 + {0xC696963C7EED2DD1, 0xE264589A4DCDAB14}, // 1e74 + {0xFC1E1DE5CF543CA2, 0x8D7EB76070A08AEC}, // 1e75 + {0x3B25A55F43294BCB, 0xB0DE65388CC8ADA8}, // 1e76 + {0x49EF0EB713F39EBE, 0xDD15FE86AFFAD912}, // 1e77 + {0x6E3569326C784337, 0x8A2DBF142DFCC7AB}, // 1e78 + {0x49C2C37F07965404, 0xACB92ED9397BF996}, // 1e79 + {0xDC33745EC97BE906, 0xD7E77A8F87DAF7FB}, // 1e80 + {0x69A028BB3DED71A3, 0x86F0AC99B4E8DAFD}, // 1e81 + {0xC40832EA0D68CE0C, 0xA8ACD7C0222311BC}, // 1e82 + {0xF50A3FA490C30190, 0xD2D80DB02AABD62B}, // 1e83 + {0x792667C6DA79E0FA, 0x83C7088E1AAB65DB}, // 1e84 + {0x577001B891185938, 0xA4B8CAB1A1563F52}, // 1e85 + {0xED4C0226B55E6F86, 0xCDE6FD5E09ABCF26}, // 1e86 + {0x544F8158315B05B4, 0x80B05E5AC60B6178}, // 1e87 + {0x696361AE3DB1C721, 0xA0DC75F1778E39D6}, // 1e88 + {0x03BC3A19CD1E38E9, 0xC913936DD571C84C}, // 1e89 + {0x04AB48A04065C723, 0xFB5878494ACE3A5F}, // 1e90 + {0x62EB0D64283F9C76, 0x9D174B2DCEC0E47B}, // 1e91 + {0x3BA5D0BD324F8394, 0xC45D1DF942711D9A}, // 1e92 + {0xCA8F44EC7EE36479, 0xF5746577930D6500}, // 1e93 + {0x7E998B13CF4E1ECB, 0x9968BF6ABBE85F20}, // 1e94 + {0x9E3FEDD8C321A67E, 0xBFC2EF456AE276E8}, // 1e95 + {0xC5CFE94EF3EA101E, 0xEFB3AB16C59B14A2}, // 1e96 + {0xBBA1F1D158724A12, 0x95D04AEE3B80ECE5}, // 1e97 + {0x2A8A6E45AE8EDC97, 0xBB445DA9CA61281F}, // 1e98 + {0xF52D09D71A3293BD, 0xEA1575143CF97226}, // 1e99 + {0x593C2626705F9C56, 0x924D692CA61BE758}, // 1e100 + {0x6F8B2FB00C77836C, 0xB6E0C377CFA2E12E}, // 1e101 + {0x0B6DFB9C0F956447, 0xE498F455C38B997A}, // 1e102 + {0x4724BD4189BD5EAC, 0x8EDF98B59A373FEC}, // 1e103 + {0x58EDEC91EC2CB657, 0xB2977EE300C50FE7}, // 1e104 + {0x2F2967B66737E3ED, 0xDF3D5E9BC0F653E1}, // 1e105 + {0xBD79E0D20082EE74, 0x8B865B215899F46C}, // 1e106 + {0xECD8590680A3AA11, 0xAE67F1E9AEC07187}, // 1e107 + {0xE80E6F4820CC9495, 0xDA01EE641A708DE9}, // 1e108 + {0x3109058D147FDCDD, 0x884134FE908658B2}, // 1e109 + {0xBD4B46F0599FD415, 0xAA51823E34A7EEDE}, // 1e110 + {0x6C9E18AC7007C91A, 0xD4E5E2CDC1D1EA96}, // 1e111 + {0x03E2CF6BC604DDB0, 0x850FADC09923329E}, // 1e112 + {0x84DB8346B786151C, 0xA6539930BF6BFF45}, // 1e113 + {0xE612641865679A63, 0xCFE87F7CEF46FF16}, // 1e114 + {0x4FCB7E8F3F60C07E, 0x81F14FAE158C5F6E}, // 1e115 + {0xE3BE5E330F38F09D, 0xA26DA3999AEF7749}, // 1e116 + {0x5CADF5BFD3072CC5, 0xCB090C8001AB551C}, // 1e117 + {0x73D9732FC7C8F7F6, 0xFDCB4FA002162A63}, // 1e118 + {0x2867E7FDDCDD9AFA, 0x9E9F11C4014DDA7E}, // 1e119 + {0xB281E1FD541501B8, 0xC646D63501A1511D}, // 1e120 + {0x1F225A7CA91A4226, 0xF7D88BC24209A565}, // 1e121 + {0x3375788DE9B06958, 0x9AE757596946075F}, // 1e122 + {0x0052D6B1641C83AE, 0xC1A12D2FC3978937}, // 1e123 + {0xC0678C5DBD23A49A, 0xF209787BB47D6B84}, // 1e124 + {0xF840B7BA963646E0, 0x9745EB4D50CE6332}, // 1e125 + {0xB650E5A93BC3D898, 0xBD176620A501FBFF}, // 1e126 + {0xA3E51F138AB4CEBE, 0xEC5D3FA8CE427AFF}, // 1e127 + {0xC66F336C36B10137, 0x93BA47C980E98CDF}, // 1e128 + {0xB80B0047445D4184, 0xB8A8D9BBE123F017}, // 1e129 + {0xA60DC059157491E5, 0xE6D3102AD96CEC1D}, // 1e130 + {0x87C89837AD68DB2F, 0x9043EA1AC7E41392}, // 1e131 + {0x29BABE4598C311FB, 0xB454E4A179DD1877}, // 1e132 + {0xF4296DD6FEF3D67A, 0xE16A1DC9D8545E94}, // 1e133 + {0x1899E4A65F58660C, 0x8CE2529E2734BB1D}, // 1e134 + {0x5EC05DCFF72E7F8F, 0xB01AE745B101E9E4}, // 1e135 + {0x76707543F4FA1F73, 0xDC21A1171D42645D}, // 1e136 + {0x6A06494A791C53A8, 0x899504AE72497EBA}, // 1e137 + {0x0487DB9D17636892, 0xABFA45DA0EDBDE69}, // 1e138 + {0x45A9D2845D3C42B6, 0xD6F8D7509292D603}, // 1e139 + {0x0B8A2392BA45A9B2, 0x865B86925B9BC5C2}, // 1e140 + {0x8E6CAC7768D7141E, 0xA7F26836F282B732}, // 1e141 + {0x3207D795430CD926, 0xD1EF0244AF2364FF}, // 1e142 + {0x7F44E6BD49E807B8, 0x8335616AED761F1F}, // 1e143 + {0x5F16206C9C6209A6, 0xA402B9C5A8D3A6E7}, // 1e144 + {0x36DBA887C37A8C0F, 0xCD036837130890A1}, // 1e145 + {0xC2494954DA2C9789, 0x802221226BE55A64}, // 1e146 + {0xF2DB9BAA10B7BD6C, 0xA02AA96B06DEB0FD}, // 1e147 + {0x6F92829494E5ACC7, 0xC83553C5C8965D3D}, // 1e148 + {0xCB772339BA1F17F9, 0xFA42A8B73ABBF48C}, // 1e149 + {0xFF2A760414536EFB, 0x9C69A97284B578D7}, // 1e150 + {0xFEF5138519684ABA, 0xC38413CF25E2D70D}, // 1e151 + {0x7EB258665FC25D69, 0xF46518C2EF5B8CD1}, // 1e152 + {0xEF2F773FFBD97A61, 0x98BF2F79D5993802}, // 1e153 + {0xAAFB550FFACFD8FA, 0xBEEEFB584AFF8603}, // 1e154 + {0x95BA2A53F983CF38, 0xEEAABA2E5DBF6784}, // 1e155 + {0xDD945A747BF26183, 0x952AB45CFA97A0B2}, // 1e156 + {0x94F971119AEEF9E4, 0xBA756174393D88DF}, // 1e157 + {0x7A37CD5601AAB85D, 0xE912B9D1478CEB17}, // 1e158 + {0xAC62E055C10AB33A, 0x91ABB422CCB812EE}, // 1e159 + {0x577B986B314D6009, 0xB616A12B7FE617AA}, // 1e160 + {0xED5A7E85FDA0B80B, 0xE39C49765FDF9D94}, // 1e161 + {0x14588F13BE847307, 0x8E41ADE9FBEBC27D}, // 1e162 + {0x596EB2D8AE258FC8, 0xB1D219647AE6B31C}, // 1e163 + {0x6FCA5F8ED9AEF3BB, 0xDE469FBD99A05FE3}, // 1e164 + {0x25DE7BB9480D5854, 0x8AEC23D680043BEE}, // 1e165 + {0xAF561AA79A10AE6A, 0xADA72CCC20054AE9}, // 1e166 + {0x1B2BA1518094DA04, 0xD910F7FF28069DA4}, // 1e167 + {0x90FB44D2F05D0842, 0x87AA9AFF79042286}, // 1e168 + {0x353A1607AC744A53, 0xA99541BF57452B28}, // 1e169 + {0x42889B8997915CE8, 0xD3FA922F2D1675F2}, // 1e170 + {0x69956135FEBADA11, 0x847C9B5D7C2E09B7}, // 1e171 + {0x43FAB9837E699095, 0xA59BC234DB398C25}, // 1e172 + {0x94F967E45E03F4BB, 0xCF02B2C21207EF2E}, // 1e173 + {0x1D1BE0EEBAC278F5, 0x8161AFB94B44F57D}, // 1e174 + {0x6462D92A69731732, 0xA1BA1BA79E1632DC}, // 1e175 + {0x7D7B8F7503CFDCFE, 0xCA28A291859BBF93}, // 1e176 + {0x5CDA735244C3D43E, 0xFCB2CB35E702AF78}, // 1e177 + {0x3A0888136AFA64A7, 0x9DEFBF01B061ADAB}, // 1e178 + {0x088AAA1845B8FDD0, 0xC56BAEC21C7A1916}, // 1e179 + {0x8AAD549E57273D45, 0xF6C69A72A3989F5B}, // 1e180 + {0x36AC54E2F678864B, 0x9A3C2087A63F6399}, // 1e181 + {0x84576A1BB416A7DD, 0xC0CB28A98FCF3C7F}, // 1e182 + {0x656D44A2A11C51D5, 0xF0FDF2D3F3C30B9F}, // 1e183 + {0x9F644AE5A4B1B325, 0x969EB7C47859E743}, // 1e184 + {0x873D5D9F0DDE1FEE, 0xBC4665B596706114}, // 1e185 + {0xA90CB506D155A7EA, 0xEB57FF22FC0C7959}, // 1e186 + {0x09A7F12442D588F2, 0x9316FF75DD87CBD8}, // 1e187 + {0x0C11ED6D538AEB2F, 0xB7DCBF5354E9BECE}, // 1e188 + {0x8F1668C8A86DA5FA, 0xE5D3EF282A242E81}, // 1e189 + {0xF96E017D694487BC, 0x8FA475791A569D10}, // 1e190 + {0x37C981DCC395A9AC, 0xB38D92D760EC4455}, // 1e191 + {0x85BBE253F47B1417, 0xE070F78D3927556A}, // 1e192 + {0x93956D7478CCEC8E, 0x8C469AB843B89562}, // 1e193 + {0x387AC8D1970027B2, 0xAF58416654A6BABB}, // 1e194 + {0x06997B05FCC0319E, 0xDB2E51BFE9D0696A}, // 1e195 + {0x441FECE3BDF81F03, 0x88FCF317F22241E2}, // 1e196 + {0xD527E81CAD7626C3, 0xAB3C2FDDEEAAD25A}, // 1e197 + {0x8A71E223D8D3B074, 0xD60B3BD56A5586F1}, // 1e198 + {0xF6872D5667844E49, 0x85C7056562757456}, // 1e199 + {0xB428F8AC016561DB, 0xA738C6BEBB12D16C}, // 1e200 + {0xE13336D701BEBA52, 0xD106F86E69D785C7}, // 1e201 + {0xECC0024661173473, 0x82A45B450226B39C}, // 1e202 + {0x27F002D7F95D0190, 0xA34D721642B06084}, // 1e203 + {0x31EC038DF7B441F4, 0xCC20CE9BD35C78A5}, // 1e204 + {0x7E67047175A15271, 0xFF290242C83396CE}, // 1e205 + {0x0F0062C6E984D386, 0x9F79A169BD203E41}, // 1e206 + {0x52C07B78A3E60868, 0xC75809C42C684DD1}, // 1e207 + {0xA7709A56CCDF8A82, 0xF92E0C3537826145}, // 1e208 + {0x88A66076400BB691, 0x9BBCC7A142B17CCB}, // 1e209 + {0x6ACFF893D00EA435, 0xC2ABF989935DDBFE}, // 1e210 + {0x0583F6B8C4124D43, 0xF356F7EBF83552FE}, // 1e211 + {0xC3727A337A8B704A, 0x98165AF37B2153DE}, // 1e212 + {0x744F18C0592E4C5C, 0xBE1BF1B059E9A8D6}, // 1e213 + {0x1162DEF06F79DF73, 0xEDA2EE1C7064130C}, // 1e214 + {0x8ADDCB5645AC2BA8, 0x9485D4D1C63E8BE7}, // 1e215 + {0x6D953E2BD7173692, 0xB9A74A0637CE2EE1}, // 1e216 + {0xC8FA8DB6CCDD0437, 0xE8111C87C5C1BA99}, // 1e217 + {0x1D9C9892400A22A2, 0x910AB1D4DB9914A0}, // 1e218 + {0x2503BEB6D00CAB4B, 0xB54D5E4A127F59C8}, // 1e219 + {0x2E44AE64840FD61D, 0xE2A0B5DC971F303A}, // 1e220 + {0x5CEAECFED289E5D2, 0x8DA471A9DE737E24}, // 1e221 + {0x7425A83E872C5F47, 0xB10D8E1456105DAD}, // 1e222 + {0xD12F124E28F77719, 0xDD50F1996B947518}, // 1e223 + {0x82BD6B70D99AAA6F, 0x8A5296FFE33CC92F}, // 1e224 + {0x636CC64D1001550B, 0xACE73CBFDC0BFB7B}, // 1e225 + {0x3C47F7E05401AA4E, 0xD8210BEFD30EFA5A}, // 1e226 + {0x65ACFAEC34810A71, 0x8714A775E3E95C78}, // 1e227 + {0x7F1839A741A14D0D, 0xA8D9D1535CE3B396}, // 1e228 + {0x1EDE48111209A050, 0xD31045A8341CA07C}, // 1e229 + {0x934AED0AAB460432, 0x83EA2B892091E44D}, // 1e230 + {0xF81DA84D5617853F, 0xA4E4B66B68B65D60}, // 1e231 + {0x36251260AB9D668E, 0xCE1DE40642E3F4B9}, // 1e232 + {0xC1D72B7C6B426019, 0x80D2AE83E9CE78F3}, // 1e233 + {0xB24CF65B8612F81F, 0xA1075A24E4421730}, // 1e234 + {0xDEE033F26797B627, 0xC94930AE1D529CFC}, // 1e235 + {0x169840EF017DA3B1, 0xFB9B7CD9A4A7443C}, // 1e236 + {0x8E1F289560EE864E, 0x9D412E0806E88AA5}, // 1e237 + {0xF1A6F2BAB92A27E2, 0xC491798A08A2AD4E}, // 1e238 + {0xAE10AF696774B1DB, 0xF5B5D7EC8ACB58A2}, // 1e239 + {0xACCA6DA1E0A8EF29, 0x9991A6F3D6BF1765}, // 1e240 + {0x17FD090A58D32AF3, 0xBFF610B0CC6EDD3F}, // 1e241 + {0xDDFC4B4CEF07F5B0, 0xEFF394DCFF8A948E}, // 1e242 + {0x4ABDAF101564F98E, 0x95F83D0A1FB69CD9}, // 1e243 + {0x9D6D1AD41ABE37F1, 0xBB764C4CA7A4440F}, // 1e244 + {0x84C86189216DC5ED, 0xEA53DF5FD18D5513}, // 1e245 + {0x32FD3CF5B4E49BB4, 0x92746B9BE2F8552C}, // 1e246 + {0x3FBC8C33221DC2A1, 0xB7118682DBB66A77}, // 1e247 + {0x0FABAF3FEAA5334A, 0xE4D5E82392A40515}, // 1e248 + {0x29CB4D87F2A7400E, 0x8F05B1163BA6832D}, // 1e249 + {0x743E20E9EF511012, 0xB2C71D5BCA9023F8}, // 1e250 + {0x914DA9246B255416, 0xDF78E4B2BD342CF6}, // 1e251 + {0x1AD089B6C2F7548E, 0x8BAB8EEFB6409C1A}, // 1e252 + {0xA184AC2473B529B1, 0xAE9672ABA3D0C320}, // 1e253 + {0xC9E5D72D90A2741E, 0xDA3C0F568CC4F3E8}, // 1e254 + {0x7E2FA67C7A658892, 0x8865899617FB1871}, // 1e255 + {0xDDBB901B98FEEAB7, 0xAA7EEBFB9DF9DE8D}, // 1e256 + {0x552A74227F3EA565, 0xD51EA6FA85785631}, // 1e257 + {0xD53A88958F87275F, 0x8533285C936B35DE}, // 1e258 + {0x8A892ABAF368F137, 0xA67FF273B8460356}, // 1e259 + {0x2D2B7569B0432D85, 0xD01FEF10A657842C}, // 1e260 + {0x9C3B29620E29FC73, 0x8213F56A67F6B29B}, // 1e261 + {0x8349F3BA91B47B8F, 0xA298F2C501F45F42}, // 1e262 + {0x241C70A936219A73, 0xCB3F2F7642717713}, // 1e263 + {0xED238CD383AA0110, 0xFE0EFB53D30DD4D7}, // 1e264 + {0xF4363804324A40AA, 0x9EC95D1463E8A506}, // 1e265 + {0xB143C6053EDCD0D5, 0xC67BB4597CE2CE48}, // 1e266 + {0xDD94B7868E94050A, 0xF81AA16FDC1B81DA}, // 1e267 + {0xCA7CF2B4191C8326, 0x9B10A4E5E9913128}, // 1e268 + {0xFD1C2F611F63A3F0, 0xC1D4CE1F63F57D72}, // 1e269 + {0xBC633B39673C8CEC, 0xF24A01A73CF2DCCF}, // 1e270 + {0xD5BE0503E085D813, 0x976E41088617CA01}, // 1e271 + {0x4B2D8644D8A74E18, 0xBD49D14AA79DBC82}, // 1e272 + {0xDDF8E7D60ED1219E, 0xEC9C459D51852BA2}, // 1e273 + {0xCABB90E5C942B503, 0x93E1AB8252F33B45}, // 1e274 + {0x3D6A751F3B936243, 0xB8DA1662E7B00A17}, // 1e275 + {0x0CC512670A783AD4, 0xE7109BFBA19C0C9D}, // 1e276 + {0x27FB2B80668B24C5, 0x906A617D450187E2}, // 1e277 + {0xB1F9F660802DEDF6, 0xB484F9DC9641E9DA}, // 1e278 + {0x5E7873F8A0396973, 0xE1A63853BBD26451}, // 1e279 + {0xDB0B487B6423E1E8, 0x8D07E33455637EB2}, // 1e280 + {0x91CE1A9A3D2CDA62, 0xB049DC016ABC5E5F}, // 1e281 + {0x7641A140CC7810FB, 0xDC5C5301C56B75F7}, // 1e282 + {0xA9E904C87FCB0A9D, 0x89B9B3E11B6329BA}, // 1e283 + {0x546345FA9FBDCD44, 0xAC2820D9623BF429}, // 1e284 + {0xA97C177947AD4095, 0xD732290FBACAF133}, // 1e285 + {0x49ED8EABCCCC485D, 0x867F59A9D4BED6C0}, // 1e286 + {0x5C68F256BFFF5A74, 0xA81F301449EE8C70}, // 1e287 + {0x73832EEC6FFF3111, 0xD226FC195C6A2F8C}, // 1e288 + {0xC831FD53C5FF7EAB, 0x83585D8FD9C25DB7}, // 1e289 + {0xBA3E7CA8B77F5E55, 0xA42E74F3D032F525}, // 1e290 + {0x28CE1BD2E55F35EB, 0xCD3A1230C43FB26F}, // 1e291 + {0x7980D163CF5B81B3, 0x80444B5E7AA7CF85}, // 1e292 + {0xD7E105BCC332621F, 0xA0555E361951C366}, // 1e293 + {0x8DD9472BF3FEFAA7, 0xC86AB5C39FA63440}, // 1e294 + {0xB14F98F6F0FEB951, 0xFA856334878FC150}, // 1e295 + {0x6ED1BF9A569F33D3, 0x9C935E00D4B9D8D2}, // 1e296 + {0x0A862F80EC4700C8, 0xC3B8358109E84F07}, // 1e297 + {0xCD27BB612758C0FA, 0xF4A642E14C6262C8}, // 1e298 + {0x8038D51CB897789C, 0x98E7E9CCCFBD7DBD}, // 1e299 + {0xE0470A63E6BD56C3, 0xBF21E44003ACDD2C}, // 1e300 + {0x1858CCFCE06CAC74, 0xEEEA5D5004981478}, // 1e301 + {0x0F37801E0C43EBC8, 0x95527A5202DF0CCB}, // 1e302 + {0xD30560258F54E6BA, 0xBAA718E68396CFFD}, // 1e303 + {0x47C6B82EF32A2069, 0xE950DF20247C83FD}, // 1e304 + {0x4CDC331D57FA5441, 0x91D28B7416CDD27E}, // 1e305 + {0xE0133FE4ADF8E952, 0xB6472E511C81471D}, // 1e306 + {0x58180FDDD97723A6, 0xE3D8F9E563A198E5}, // 1e307 + {0x570F09EAA7EA7648, 0x8E679C2F5E44FF8F}, // 1e308 + {0x2CD2CC6551E513DA, 0xB201833B35D63F73}, // 1e309 + {0xF8077F7EA65E58D1, 0xDE81E40A034BCF4F}, // 1e310 + {0xFB04AFAF27FAF782, 0x8B112E86420F6191}, // 1e311 + {0x79C5DB9AF1F9B563, 0xADD57A27D29339F6}, // 1e312 + {0x18375281AE7822BC, 0xD94AD8B1C7380874}, // 1e313 + {0x8F2293910D0B15B5, 0x87CEC76F1C830548}, // 1e314 + {0xB2EB3875504DDB22, 0xA9C2794AE3A3C69A}, // 1e315 + {0x5FA60692A46151EB, 0xD433179D9C8CB841}, // 1e316 + {0xDBC7C41BA6BCD333, 0x849FEEC281D7F328}, // 1e317 + {0x12B9B522906C0800, 0xA5C7EA73224DEFF3}, // 1e318 + {0xD768226B34870A00, 0xCF39E50FEAE16BEF}, // 1e319 + {0xE6A1158300D46640, 0x81842F29F2CCE375}, // 1e320 + {0x60495AE3C1097FD0, 0xA1E53AF46F801C53}, // 1e321 + {0x385BB19CB14BDFC4, 0xCA5E89B18B602368}, // 1e322 + {0x46729E03DD9ED7B5, 0xFCF62C1DEE382C42}, // 1e323 + {0x6C07A2C26A8346D1, 0x9E19DB92B4E31BA9}, // 1e324 + {0xC7098B7305241885, 0xC5A05277621BE293}, // 1e325 + {0xB8CBEE4FC66D1EA7, 0xF70867153AA2DB38}, // 1e326 + {0x737F74F1DC043328, 0x9A65406D44A5C903}, // 1e327 + {0x505F522E53053FF2, 0xC0FE908895CF3B44}, // 1e328 + {0x647726B9E7C68FEF, 0xF13E34AABB430A15}, // 1e329 + {0x5ECA783430DC19F5, 0x96C6E0EAB509E64D}, // 1e330 + {0xB67D16413D132072, 0xBC789925624C5FE0}, // 1e331 + {0xE41C5BD18C57E88F, 0xEB96BF6EBADF77D8}, // 1e332 + {0x8E91B962F7B6F159, 0x933E37A534CBAAE7}, // 1e333 + {0x723627BBB5A4ADB0, 0xB80DC58E81FE95A1}, // 1e334 + {0xCEC3B1AAA30DD91C, 0xE61136F2227E3B09}, // 1e335 + {0x213A4F0AA5E8A7B1, 0x8FCAC257558EE4E6}, // 1e336 + {0xA988E2CD4F62D19D, 0xB3BD72ED2AF29E1F}, // 1e337 + {0x93EB1B80A33B8605, 0xE0ACCFA875AF45A7}, // 1e338 + {0xBC72F130660533C3, 0x8C6C01C9498D8B88}, // 1e339 + {0xEB8FAD7C7F8680B4, 0xAF87023B9BF0EE6A}, // 1e340 + {0xA67398DB9F6820E1, 0xDB68C2CA82ED2A05}, // 1e341 + {0x88083F8943A1148C, 0x892179BE91D43A43}, // 1e342 + {0x6A0A4F6B948959B0, 0xAB69D82E364948D4}, // 1e343 + {0x848CE34679ABB01C, 0xD6444E39C3DB9B09}, // 1e344 + {0xF2D80E0C0C0B4E11, 0x85EAB0E41A6940E5}, // 1e345 + {0x6F8E118F0F0E2195, 0xA7655D1D2103911F}, // 1e346 + {0x4B7195F2D2D1A9FB, 0xD13EB46469447567}, // 1e347 +}; diff --git a/native/arm/atof_native.h b/native/arm/atof_native.h new file mode 100644 index 000000000..e5328dbcc --- /dev/null +++ b/native/arm/atof_native.h @@ -0,0 +1,505 @@ +/* + * 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. + */ + +#pragma once + +#include "native.h" + +/* decimical shift witout overflow, e.g. 9 << 61 overflow */ +#define MAX_SHIFT 60 + +/* Decimal represent the integer or float + * example 1: 1.1 {"11", 2, 1, 0} + * example 2: -0.1 {"1", 1, 0, 1} + * example 3: 999 {"999", 3, 3, 0} + */ +typedef struct Decimal { + char* d; + size_t cap; + int nd; + int dp; + int neg; + int trunc; +} Decimal; + +/* decimal power of ten to binary power of two. + * For example: POW_TAB[1]: 10 ** 1 ~ 2 ** 3 + */ +static const int POW_TAB[9] = {1, 3, 6, 9, 13, 16, 19, 23, 26}; + +/* Left shift information for decimal. + * For example, {2, "625"}. That means that it will add 2 digits to the new decimal + * when the prefix of decimal is from "625" to "999", and 1 digit from "0" to "624". + */ +typedef struct lshift_cheat { + int delta; // number of added digits when left shift + const char cutoff[100]; // minus one digit if under the half(cutoff). +} lshift_cheat; + +/* Look up for the decimal shift information by binary shift bits. + * idx is shift bits for binary. + * value is the shift information for decimal. + * For example, idx is 4, the value is {2, "625"}. + * That means the binary shift 4 bits left, will cause add 2 digits to the decimal + * if the prefix of decimal is under "625". + */ +const static lshift_cheat LSHIFT_TAB[61]; + +static always_inline void decimal_init(Decimal *d, char *dbuf, size_t cap) { + d->d = dbuf; + d->cap = cap; + for (int i = 0; i < d->cap; ++i) { + d->d[i] = 0; + } + d->dp = 0; + d->nd = 0; + d->neg = 0; + d->trunc = 0; +} + +static always_inline void decimal_set(Decimal *d, const char *s, ssize_t len, char *dbuf, ssize_t cap) { + int i = 0; + + decimal_init(d, dbuf, cap); + if (s[i] == '-') { + i++; + d->neg = 1; + } + + int saw_dot = 0; + for (; i < len; i++) { + if ('0' <= s[i] && s[i] <= '9') { + if (s[i] == '0' && d->nd == 0) { // ignore leading zeros + d->dp--; + continue; + } + if (d->nd < d->cap) { + d->d[d->nd] = s[i]; + d->nd++; + } else if (s[i] != '0') { + /* truncat the remaining digits */ + d->trunc = 1; + } + } else if (s[i] == '.') { + saw_dot = 1; + d->dp = d->nd; + } else { + break; + } + } + + /* integer */ + if (saw_dot == 0) { + d->dp = d->nd; + } + + /* exponent */ + if (i < len && (s[i] == 'e' || s[i] == 'E')) { + int exp = 0; + int esgn = 1; + + i++; + if (s[i] == '+') { + i++; + } else if (s[i] == '-') { + i++; + esgn = -1; + } + + for (; i < len && ('0' <= s[i] && s[i] <= '9') && exp < 10000; i++) { + exp = exp * 10 + (s[i] - '0'); + } + d->dp += exp * esgn; + } + + return; +} + +/* trim trailing zeros from number */ +static always_inline void trim(Decimal *d) { + while (d->nd > 0 && d->d[d->nd - 1] == '0') { + d->nd--; + } + if (d->nd == 0) { + d->dp = 0; + } +} + +/* Binary shift right (/ 2) by k bits. k <= maxShift to avoid overflow */ +static always_inline void right_shift(Decimal *d, uint32_t k) { + int r = 0; // read pointer + int w = 0; // write pointer + uint64_t n = 0; + + /* Pick up enough leading digits to cover first shift */ + for (; n >> k == 0; r++) { + if (r >= d->nd) { + if (n == 0) { + d->nd = 0; // no digits for this num + return; + } + /* until n has enough bits for right shift */ + while (n >> k == 0) { + n *= 10; + r++; + } + break; + } + n = n * 10 + d->d[r] - '0'; // read the value from d.d + } + d->dp -= r - 1; // point shift left + + uint64_t mask = (1ull << k) - 1; + uint64_t dig = 0; + + /* Pick up a digit, put down a digit */ + for (; r < d->nd; r++) { + dig = n >> k; + n &= mask; + d->d[w++] = (char)(dig + '0'); + n = n * 10 + d->d[r] - '0'; + } + + /* Put down extra digits */ + while (n > 0) { + dig = n >> k; + n &= mask; + if (w < d->cap) { + d->d[w] = (char)(dig + '0'); + w++; + } else if (dig > 0) { + /* truncated */ + d->trunc = 1; + } + n *= 10; + } + + d->nd = w; + trim(d); +} + +/* Compare the leading prefix, if b is lexicographically less, return 0 */ +static always_inline bool prefix_is_less(const char *b, const char *s, uint64_t bn) { + int i = 0; + for (; i < bn; i++) { + if (s[i] == '\0') { + return false; + } + if (b[i] != s[i]) { + return b[i] < s[i]; + } + } + return s[i] != '\0'; +} + +/* Binary shift left (* 2) by k bits. k <= maxShift to avoid overflow */ +static always_inline void left_shift(Decimal *d, uint32_t k) { + int delta = LSHIFT_TAB[k].delta; + + if (prefix_is_less(d->d, LSHIFT_TAB[k].cutoff, d->nd)){ + delta--; + } + + int r = d->nd; // read index + int w = d->nd + delta; // write index + uint64_t n = 0; + uint64_t quo = 0; + uint64_t rem = 0; + + /* Pick up a digit, put down a digit */ + for (r--; r >= 0; r--) { + n += (uint64_t)(d->d[r] - '0') << k; + quo = n / 10; + rem = n - 10 * quo; + w--; + if (w < d->cap) { + d->d[w] = (char)(rem + '0'); + } else if (rem != 0) { + /* truncated */ + d->trunc = 1; + } + n = quo; + } + + /* Put down extra digits */ + while (n > 0) { + quo = n / 10; + rem = n - 10 * quo; + w--; + if (w < d->cap) { + d->d[w] = (char)(rem + '0'); + } else if (rem != 0) { + /* truncated */ + d->trunc = 1; + } + n = quo; + } + + d->nd += delta; + if (d->nd >= d->cap) { + d->nd = d->cap; + } + d->dp += delta; + trim(d); +} + +static always_inline void decimal_shift(Decimal *d, int k) { + if (d->nd == 0 || k == 0) { + return; + } + + if (k > 0) { + while (k > MAX_SHIFT) { + left_shift(d, MAX_SHIFT); + k -= MAX_SHIFT; + } + if (k) { + left_shift(d, k); + } + } + + if (k < 0) { + while (k < -MAX_SHIFT) { + right_shift(d, MAX_SHIFT); + k += MAX_SHIFT; + } + if (k) { + right_shift(d, -k); + } + } + +} + +static always_inline int should_roundup(Decimal *d, int nd) { + if (nd < 0 || nd >= d->nd) { + return 0; + } + + /* Exactly halfway - round to even */ + if (d->d[nd] == '5' && nd+1 == d->nd) { + if (d->trunc) { + return 1; + } + return nd > 0 && (d->d[nd-1]-'0')%2 != 0; + } + + /* not halfway - round to the nearest */ + return d->d[nd] >= '5'; +} + +/* Extract integer part, rounded appropriately */ +static always_inline uint64_t rounded_integer(Decimal *d) { + if (d->dp > 20) { // overflow + return 0xFFFFFFFFFFFFFFFF; //64 bits + } + + int i = 0; + uint64_t n = 0; + for (i = 0; i < d->dp && i < d->nd; i++) { + n = n * 10 + (d->d[i] - '0'); + } + for (; i < d->dp; i++) { + n *= 10; + } + if (should_roundup(d, d->dp)) { + n++; + } + return n; +} + +static always_inline int decimal_to_f64(Decimal *d, double *val) { + int exp2 = 0; + uint64_t mant = 0; + uint64_t bits = 0; + + /* d is zero */ + if (d->nd == 0) { + mant = 0; + exp2 = -1023; + goto out; + } + + /* Overflow, return inf/INF */ + if (d->dp > 310) { + goto overflow; + } + /* Underflow, return zero */ + if (d->dp < -330) { + mant = 0; + exp2 = -1023; + goto out; + } + + /* Scale by powers of two until in range [0.5, 1.0) */ + int n = 0; + while (d->dp > 0) { // d >= 1 + if (d->dp >= 9) { + n = 27; + } else { + n = POW_TAB[d->dp]; + } + decimal_shift(d, -n); // shift right + exp2 += n; + } + while ((d->dp < 0) || ((d->dp == 0) && (d->d[0] < '5'))) { // d < 0.5 + if (-d->dp >= 9) { + n = 27; + } else { + n = POW_TAB[-d->dp]; + } + decimal_shift(d, n); // shift left + exp2 -= n; + } + + /* Our range is [0.5,1) but floating point range is [1,2) */ + exp2 --; + + /* Minimum exp2 for doulbe is -1022. + * If the exponent is smaller, move it up and + * adjust d accordingly. + */ + if (exp2 < -1022) { + n = -1022 - exp2; + decimal_shift(d, -n); // shift right + exp2 += n; + } + + /* Exp2 too large */ + if ((exp2 + 1023) >= 0x7FF) { + goto overflow; + } + + /* Extract 53 bits. */ + decimal_shift(d, 53); // shift left + mant = rounded_integer(d); + + /* Rounding might have added a bit; shift down. */ + if (mant == (2ull << 52)) { // mant has 54 bits + mant >>= 1; + exp2 ++; + if ((exp2 + 1023) >= 0x7FF) { + goto overflow; + } + } + + /* Denormalized? */ + if ((mant & (1ull << 52)) == 0) { + exp2 = -1023; + } + goto out; + +overflow: + /* ±INF/inf */ + mant = 0; + exp2 = 0x7FF - 1023; + +out: + /* Assemble bits. */ + bits = mant & 0x000FFFFFFFFFFFFF; + bits |= (uint64_t)((exp2 + 1023) & 0x7FF) << 52; + if (d->neg) { + bits |= 1ull << 63; + } + *(uint64_t*)val = bits; + return 0; +} + +static INLINE_FOR_ARM double atof_native_1(const char *sp, ssize_t nb, char* dbuf, ssize_t cap) { + Decimal d; + double val = 0; + decimal_set(&d, sp, nb, dbuf, cap); + decimal_to_f64(&d, &val); + return val; +} + +#undef MAX_SHIFT + +const static lshift_cheat LSHIFT_TAB[61] = { + // Leading digits of 1/2^i = 5^i. + // 5^23 is not an exact 64-bit floating point number, + // so have to use bc for the math. + // Go up to 60 to be large enough for 32bit and 64bit platforms. + /* + seq 60 | sed 's/^/5^/' | bc | + awk 'BEGIN{ print "\t{ 0, \"\" }," } + { + log2 = log(2)/log(10) + printf("\t{ %d, \"%s\" },\t// * %d\n", + int(log2*NR+1), $0, 2**NR) + }' + */ + {0, ""}, + {1, "5"}, // * 2 + {1, "25"}, // * 4 + {1, "125"}, // * 8 + {2, "625"}, // * 16 + {2, "3125"}, // * 32 + {2, "15625"}, // * 64 + {3, "78125"}, // * 128 + {3, "390625"}, // * 256 + {3, "1953125"}, // * 512 + {4, "9765625"}, // * 1024 + {4, "48828125"}, // * 2048 + {4, "244140625"}, // * 4096 + {4, "1220703125"}, // * 8192 + {5, "6103515625"}, // * 16384 + {5, "30517578125"}, // * 32768 + {5, "152587890625"}, // * 65536 + {6, "762939453125"}, // * 131072 + {6, "3814697265625"}, // * 262144 + {6, "19073486328125"}, // * 524288 + {7, "95367431640625"}, // * 1048576 + {7, "476837158203125"}, // * 2097152 + {7, "2384185791015625"}, // * 4194304 + {7, "11920928955078125"}, // * 8388608 + {8, "59604644775390625"}, // * 16777216 + {8, "298023223876953125"}, // * 33554432 + {8, "1490116119384765625"}, // * 67108864 + {9, "7450580596923828125"}, // * 134217728 + {9, "37252902984619140625"}, // * 268435456 + {9, "186264514923095703125"}, // * 536870912 + {10, "931322574615478515625"}, // * 1073741824 + {10, "4656612873077392578125"}, // * 2147483648 + {10, "23283064365386962890625"}, // * 4294967296 + {10, "116415321826934814453125"}, // * 8589934592 + {11, "582076609134674072265625"}, // * 17179869184 + {11, "2910383045673370361328125"}, // * 34359738368 + {11, "14551915228366851806640625"}, // * 68719476736 + {12, "72759576141834259033203125"}, // * 137438953472 + {12, "363797880709171295166015625"}, // * 274877906944 + {12, "1818989403545856475830078125"}, // * 549755813888 + {13, "9094947017729282379150390625"}, // * 1099511627776 + {13, "45474735088646411895751953125"}, // * 2199023255552 + {13, "227373675443232059478759765625"}, // * 4398046511104 + {13, "1136868377216160297393798828125"}, // * 8796093022208 + {14, "5684341886080801486968994140625"}, // * 17592186044416 + {14, "28421709430404007434844970703125"}, // * 35184372088832 + {14, "142108547152020037174224853515625"}, // * 70368744177664 + {15, "710542735760100185871124267578125"}, // * 140737488355328 + {15, "3552713678800500929355621337890625"}, // * 281474976710656 + {15, "17763568394002504646778106689453125"}, // * 562949953421312 + {16, "88817841970012523233890533447265625"}, // * 1125899906842624 + {16, "444089209850062616169452667236328125"}, // * 2251799813685248 + {16, "2220446049250313080847263336181640625"}, // * 4503599627370496 + {16, "11102230246251565404236316680908203125"}, // * 9007199254740992 + {17, "55511151231257827021181583404541015625"}, // * 18014398509481984 + {17, "277555756156289135105907917022705078125"}, // * 36028797018963968 + {17, "1387778780781445675529539585113525390625"}, // * 72057594037927936 + {18, "6938893903907228377647697925567626953125"}, // * 144115188075855872 + {18, "34694469519536141888238489627838134765625"}, // * 288230376151711744 + {18, "173472347597680709441192448139190673828125"}, // * 576460752303423488 + {19, "867361737988403547205962240695953369140625"}, // * 1152921504606846976 +}; diff --git a/native/arm/f32toa.c b/native/arm/f32toa.c new file mode 100644 index 000000000..268f5bf6d --- /dev/null +++ b/native/arm/f32toa.c @@ -0,0 +1,454 @@ +/* Copyright 2020 Alexander Bolz + * + * Boost Software License - Version 1.0 - August 17th, 2003 + * + * Permission is hereby granted, free of charge, to any person or organization + * obtaining a copy of the software and accompanying documentation covered by + * this license (the "Software") to use, reproduce, display, distribute, + * execute, and transmit the Software, and to prepare derivative works of the + * Software, and to permit third-parties to whom the Software is furnished to + * do so, all subject to the following: + * + * The copyright notices in the Software and this entire statement, including + * the above license grant, this restriction and the following disclaimer, + * must be included in all copies of the Software, in whole or in part, and + * all derivative works of the Software, unless such copies or derivative + * works are solely in the form of machine-executable object code generated by + * a source language processor. + * + * Unless required by applicable law or agreed to in writing, this software + * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. + * + * This file may have been modified by ByteDance authors. All ByteDance + * Modifications are Copyright 2022 ByteDance Authors. + */ + +#include "native.h" +#include "tab.h" +#include "test/xassert.h" + +#define F32_BITS 32 +#define F32_EXP_BITS 8 +#define F32_SIG_BITS 23 +#define F32_EXP_MASK 0x7F800000u // middle 8 bits +#define F32_SIG_MASK 0x007FFFFFu // lower 23 bits +#define F32_EXP_BIAS 127 +#define F32_INF_NAN_EXP 0xFF +#define F32_HIDDEN_BIT 0x00800000u + +typedef struct { + uint32_t sig; + int32_t exp; +} f32_dec; + +typedef __uint128_t uint128_t; + +static always_inline unsigned ctz10_u32(const uint32_t v) { + xassert(0 <= v && v < 1000000000u); + if (v >= 100000) { + if (v < 1000000) return 6; + if (v < 10000000) return 7; + if (v < 100000000) return 8; + else return 9; + } else { + if (v < 10) return 1; + if (v < 100) return 2; + if (v < 1000) return 3; + if (v < 10000) return 4; + else return 5; + } +} + +static always_inline char* format_significand_f32(uint32_t sig, char *out, int cnt) { + char *r = out + cnt; + int ctz = 0; + + /* at most 9 digits here */ + if (sig >= 10000) { + uint32_t c = sig - 10000 * (sig / 10000); + sig /= 10000; + if (c != 0) { + uint32_t c0 = (c % 100) << 1; + uint32_t c1 = (c / 100) << 1; + copy_two_digs(r - 2, Digits + c0); + copy_two_digs(r - 4, Digits + c1); + } else { + ctz = 4; + } + r -= 4; + } + + while (sig >= 100) { + uint32_t c = (sig % 100) << 1; + sig /= 100; + copy_two_digs(r - 2, Digits + c); + r -= 2; + } + + if (sig >= 10) { + uint32_t c = sig << 1; + copy_two_digs(out, Digits + c); + } else { + *out = (char) ('0' + sig); + } + + return out + cnt - ctz; +} + +static always_inline char* format_integer_u32(uint32_t sig, char *out, unsigned cnt) { + char *r = out + cnt; + + /* at most 9 digits here */ + if (sig >= 10000) { + uint32_t c = sig - 10000 * (sig / 10000); + sig /= 10000; + uint32_t c0 = (c % 100) << 1; + uint32_t c1 = (c / 100) << 1; + copy_two_digs(r - 2, Digits + c0); + copy_two_digs(r - 4, Digits + c1); + r -= 4; + } + + while (sig >= 100) { + uint32_t c = (sig % 100) << 1; + sig /= 100; + copy_two_digs(r - 2, Digits + c); + r -= 2; + } + + if (sig >= 10) { + uint32_t c = sig << 1; + copy_two_digs(out, Digits + c); + } else { + *out = (char) ('0' + sig); + } + + return out + cnt; +} + +static always_inline char* format_exponent_f32(f32_dec v, char *out, int cnt) { + char* p = out + 1; + char* end = format_significand_f32(v.sig, p, cnt); + while (*(end - 1) == '0') end--; + + /* Print decimal point if needed */ + *out = *p; + if (end - p > 1) { + *p = '.'; + } else { + end--; + } + + /* Print the exponent */ + *end++ = 'e'; + int32_t exp = v.exp + (int32_t) cnt - 1; + if (exp < 0) { + *end++ = '-'; + exp = -exp; + } else { + *end++ = '+'; + } + + if (exp >= 100) { + int32_t c = exp % 10; + copy_two_digs(end, Digits + 2 * (exp / 10)); + end[2] = (char) ('0' + c); + end += 3; + } else if (exp >= 10) { + copy_two_digs(end, Digits + 2 * exp); + end += 2; + } else { + *end++ = (char) ('0' + exp); + } + return end; +} + +static always_inline char* format_decimal_f32(f32_dec v, char* out, int cnt) { + char* p = out; + char* end; + int point = cnt + v.exp; + + /* print leading zeros if fp < 1 */ + if (point <= 0) { + *p++ = '0', *p++ = '.'; + for (int i = 0; i < -point; i++) { + *p++ = '0'; + } + } + + /* add the remaining digits */ + end = format_significand_f32(v.sig, p, cnt); + while (*(end - 1) == '0') end--; + if (point <= 0) { + return end; + } + + /* insert point or add trailing zeros */ + int digs = end - p, frac = digs - point; + if (digs > point) { + for (int i = 0; i < frac; i++) { + *(end - i) = *(end - i - 1); + } + p[point] = '.'; + end++; + } else { + for (int i = 0; i < point - digs; i++) { + *end++ = '0'; + } + } + return end; +} + +static always_inline char* write_dec_f32(f32_dec dec, char* p) { + int cnt = ctz10_u32(dec.sig); + int dot = cnt + dec.exp; + int sci_exp = dot - 1; + bool exp_fmt = sci_exp < -6 || sci_exp > 20; + bool has_dot = dot < cnt; + + if (exp_fmt) { + return format_exponent_f32(dec, p, cnt); + } + if (has_dot) { + return format_decimal_f32(dec, p, cnt); + } + + char* end = p + dot; + p = format_integer_u32(dec.sig, p, cnt); + while (p < end) *p++ = '0'; + return end; +} + +static always_inline uint32_t f32toraw(float fp) { + union { + uint32_t u32; + float f32; + } uval; + uval.f32 = fp; + return uval.u32; +} + +static always_inline uint64_t pow10_ceil_sig_f32(int32_t k) +{ + // There are unique beta and r such that 10^k = beta 2^r and + // 2^63 <= beta < 2^64, namely r = floor(log_2 10^k) - 63 and + // beta = 2^-r 10^k. + // Let g = ceil(beta), so (g-1) 2^r < 10^k <= g 2^r, with the latter + // value being a pretty good overestimate for 10^k. + + // NB: Since for all the required exponents k, we have g < 2^64, + // all constants can be stored in 128-bit integers. + // reference from: + // https://github.com/abolz/Drachennest/blob/master/src/schubfach_32.cc#L144 + +#define KMAX 45 +#define KMIN -31 + static const uint64_t g[KMAX - KMIN + 1] = { + 0x81CEB32C4B43FCF5, // -31 + 0xA2425FF75E14FC32, // -30 + 0xCAD2F7F5359A3B3F, // -29 + 0xFD87B5F28300CA0E, // -28 + 0x9E74D1B791E07E49, // -27 + 0xC612062576589DDB, // -26 + 0xF79687AED3EEC552, // -25 + 0x9ABE14CD44753B53, // -24 + 0xC16D9A0095928A28, // -23 + 0xF1C90080BAF72CB2, // -22 + 0x971DA05074DA7BEF, // -21 + 0xBCE5086492111AEB, // -20 + 0xEC1E4A7DB69561A6, // -19 + 0x9392EE8E921D5D08, // -18 + 0xB877AA3236A4B44A, // -17 + 0xE69594BEC44DE15C, // -16 + 0x901D7CF73AB0ACDA, // -15 + 0xB424DC35095CD810, // -14 + 0xE12E13424BB40E14, // -13 + 0x8CBCCC096F5088CC, // -12 + 0xAFEBFF0BCB24AAFF, // -11 + 0xDBE6FECEBDEDD5BF, // -10 + 0x89705F4136B4A598, // -9 + 0xABCC77118461CEFD, // -8 + 0xD6BF94D5E57A42BD, // -7 + 0x8637BD05AF6C69B6, // -6 + 0xA7C5AC471B478424, // -5 + 0xD1B71758E219652C, // -4 + 0x83126E978D4FDF3C, // -3 + 0xA3D70A3D70A3D70B, // -2 + 0xCCCCCCCCCCCCCCCD, // -1 + 0x8000000000000000, // 0 + 0xA000000000000000, // 1 + 0xC800000000000000, // 2 + 0xFA00000000000000, // 3 + 0x9C40000000000000, // 4 + 0xC350000000000000, // 5 + 0xF424000000000000, // 6 + 0x9896800000000000, // 7 + 0xBEBC200000000000, // 8 + 0xEE6B280000000000, // 9 + 0x9502F90000000000, // 10 + 0xBA43B74000000000, // 11 + 0xE8D4A51000000000, // 12 + 0x9184E72A00000000, // 13 + 0xB5E620F480000000, // 14 + 0xE35FA931A0000000, // 15 + 0x8E1BC9BF04000000, // 16 + 0xB1A2BC2EC5000000, // 17 + 0xDE0B6B3A76400000, // 18 + 0x8AC7230489E80000, // 19 + 0xAD78EBC5AC620000, // 20 + 0xD8D726B7177A8000, // 21 + 0x878678326EAC9000, // 22 + 0xA968163F0A57B400, // 23 + 0xD3C21BCECCEDA100, // 24 + 0x84595161401484A0, // 25 + 0xA56FA5B99019A5C8, // 26 + 0xCECB8F27F4200F3A, // 27 + 0x813F3978F8940985, // 28 + 0xA18F07D736B90BE6, // 29 + 0xC9F2C9CD04674EDF, // 30 + 0xFC6F7C4045812297, // 31 + 0x9DC5ADA82B70B59E, // 32 + 0xC5371912364CE306, // 33 + 0xF684DF56C3E01BC7, // 34 + 0x9A130B963A6C115D, // 35 + 0xC097CE7BC90715B4, // 36 + 0xF0BDC21ABB48DB21, // 37 + 0x96769950B50D88F5, // 38 + 0xBC143FA4E250EB32, // 39 + 0xEB194F8E1AE525FE, // 40 + 0x92EFD1B8D0CF37BF, // 41 + 0xB7ABC627050305AE, // 42 + 0xE596B7B0C643C71A, // 43 + 0x8F7E32CE7BEA5C70, // 44 + 0xB35DBF821AE4F38C, // 45 + }; + + xassert(k >= KMIN && k <= KMAX); + return g[k - KMIN]; +#undef KMIN +#undef KMAX +} + +static always_inline uint32_t round_odd_f32(uint64_t g, uint32_t cp) { + const uint128_t p = ((uint128_t)g) * cp; + const uint32_t y1 = (uint64_t)(p >> 64); + const uint32_t y0 = ((uint64_t)(p)) >> 32; + return y1 | (y0 > 1); +} + +/** + Rendering float point number into decimal. + The function used Schubfach algorithm, reference: + The Schubfach way to render doubles, Raffaello Giulietti, 2022-03-20. + https://drive.google.com/file/d/1gp5xv4CAa78SVgCeWfGqqI4FfYYYuNFb + https://mail.openjdk.java.net/pipermail/core-libs-dev/2021-November/083536.html + https://github.com/openjdk/jdk/pull/3402 (Java implementation) + https://github.com/abolz/Drachennest (C++ implementation) + */ +static always_inline f32_dec f32todec(uint32_t rsig, int32_t rexp, uint32_t c, int32_t q) { + uint32_t cbl, cb, cbr, vbl, vb, vbr, lower, upper, s; + int32_t k, h; + bool even, irregular, w_inside, u_inside; + f32_dec dec; + + even = !(c & 1); + irregular = rsig == 0 && rexp > 1; + + cbl = 4 * c - 2 + irregular; + cb = 4 * c; + cbr = 4 * c + 2; + + k = (q * 1262611 - (irregular ? 524031 : 0)) >> 22; + h = q + ((-k) * 1741647 >> 19) + 1; + uint64_t pow10 = pow10_ceil_sig_f32(-k); + vbl = round_odd_f32(pow10, cbl << h); + vb = round_odd_f32(pow10, cb << h); + vbr = round_odd_f32(pow10, cbr << h); + + + lower = vbl + !even; + upper = vbr - !even; + + s = vb / 4; + if (s >= 10) { + uint64_t sp = s / 10; + bool up_inside = lower <= (40 * sp); + bool wp_inside = (40 * sp + 40) <= upper; + if (up_inside != wp_inside) { + dec.sig = sp + wp_inside; + dec.exp = k + 1; + return dec; + } + } + + u_inside = lower <= (4 * s); + w_inside = (4 * s + 4) <= upper; + if (u_inside != w_inside) { + dec.sig = s + w_inside; + dec.exp = k; + return dec; + } + + uint64_t mid = 4 * s + 2; + bool round_up = vb > mid || (vb == mid && (s & 1) != 0); + dec.sig = s + round_up; + dec.exp = k; + return dec; +} + + int f32toa(char *out, float fp) { + char* p = out; + uint32_t raw = f32toraw(fp); + bool neg; + uint32_t rsig, c; + int32_t rexp, q; + + neg = ((raw >> (F32_BITS - 1)) != 0); + rsig = raw & F32_SIG_MASK; + rexp = (int32_t)((raw & F32_EXP_MASK) >> F32_SIG_BITS); + + /* check infinity and nan */ + if (unlikely(rexp == F32_INF_NAN_EXP)) { + return 0; + } + + /* check negative numbers */ + *p = '-'; + p += neg; + + /* simple case of 0.0 */ + if ((raw << 1) == 0) { + *p++ = '0'; + return p - out; + } + + if (likely(rexp != 0)) { + /* double is normal */ + c = rsig | F32_HIDDEN_BIT; + q = rexp - F32_EXP_BIAS - F32_SIG_BITS; + + /* fast path for integer */ + if (q <= 0 && q >= -F32_SIG_BITS && is_div_pow2(c, -q)) { + uint32_t u = c >> -q; + p = format_integer_u32(u, p, ctz10_u32(u)); + return p - out; + } + } else { + c = rsig; + q = 1 - F32_EXP_BIAS - F32_SIG_BITS; + } + + f32_dec dec = f32todec(rsig, rexp, c, q); + p = write_dec_f32(dec, p); + return p - out; +} + +#undef F32_BITS +#undef F32_EXP_BITS +#undef F32_SIG_BITS +#undef F32_EXP_MASK +#undef F32_SIG_MASK +#undef F32_EXP_BIAS +#undef F32_INF_NAN_EXP +#undef F32_HIDDEN_BIT diff --git a/native/arm/f64toa.c b/native/arm/f64toa.c new file mode 100644 index 000000000..2f9e4561c --- /dev/null +++ b/native/arm/f64toa.c @@ -0,0 +1,405 @@ +/* Copyright 2020 Alexander Bolz + * + * Boost Software License - Version 1.0 - August 17th, 2003 + * + * Permission is hereby granted, free of charge, to any person or organization + * obtaining a copy of the software and accompanying documentation covered by + * this license (the "Software") to use, reproduce, display, distribute, + * execute, and transmit the Software, and to prepare derivative works of the + * Software, and to permit third-parties to whom the Software is furnished to + * do so, all subject to the following: + * + * The copyright notices in the Software and this entire statement, including + * the above license grant, this restriction and the following disclaimer, + * must be included in all copies of the Software, in whole or in part, and + * all derivative works of the Software, unless such copies or derivative + * works are solely in the form of machine-executable object code generated by + * a source language processor. + * + * Unless required by applicable law or agreed to in writing, this software + * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. + * + * This file may have been modified by ByteDance authors. All ByteDance + * Modifications are Copyright 2022 ByteDance Authors. + */ + +#include "native.h" +#include "tab.h" +#include "test/xassert.h" + +#define F64_BITS 64 +#define F64_EXP_BITS 11 +#define F64_SIG_BITS 52 +#define F64_EXP_MASK 0x7FF0000000000000ull // middle 11 bits +#define F64_SIG_MASK 0x000FFFFFFFFFFFFFull // lower 52 bits +#define F64_EXP_BIAS 1023 +#define F64_INF_NAN_EXP 0x7FF +#define F64_HIDDEN_BIT 0x0010000000000000ull + +struct f64_dec { + uint64_t sig; + int64_t exp; +}; +typedef struct f64_dec f64_dec; + +typedef __uint128_t uint128_t; + +static always_inline unsigned ctz10(const uint64_t v) { + xassert(0 <= v && v < 100000000000000000ull); + if (v >= 10000000000ull) { + if (v < 100000000000ull) return 11; + if (v < 1000000000000ull) return 12; + if (v < 10000000000000ull) return 13; + if (v < 100000000000000ull) return 14; + if (v < 1000000000000000ull) return 15; + if (v < 10000000000000000ull) return 16; + else return 17; + } + if (v < 10ull) return 1; + if (v < 100ull) return 2; + if (v < 1000ull) return 3; + if (v < 10000ull) return 4; + if (v < 100000ull) return 5; + if (v < 1000000ull) return 6; + if (v < 10000000ull) return 7; + if (v < 100000000ull) return 8; + if (v < 1000000000ull) return 9; + else return 10; + +} + +static always_inline char* format_significand(uint64_t sig, char *out, int cnt) { + char *p = out + cnt; + int ctz = 0; + + if ((sig >> 32) != 0) { + uint64_t q = sig / 100000000; + uint32_t r = ((uint32_t)sig) - 100000000 * ((uint32_t) q); + sig = q; + if (r != 0) { + uint32_t c = r % 10000; + r /= 10000; + uint32_t d = r % 10000; + uint32_t c0 = (c % 100) << 1; + uint32_t c1 = (c / 100) << 1; + uint32_t d0 = (d % 100) << 1; + uint32_t d1 = (d / 100) << 1; + copy_two_digs(p - 2, Digits + c0); + copy_two_digs(p - 4, Digits + c1); + copy_two_digs(p - 6, Digits + d0); + copy_two_digs(p - 8, Digits + d1); + } else { + ctz += 8; + } + p -= 8; + } + + uint32_t sig2 = (uint32_t)sig; + while (sig2 >= 10000) { + uint32_t c = sig2 - 10000 * (sig2 / 10000); + sig2 /= 10000; + uint32_t c0 = (c % 100) << 1; + uint32_t c1 = (c / 100) << 1; + copy_two_digs(p - 2, Digits + c0); + copy_two_digs(p - 4, Digits + c1); + p -= 4; + } + if (sig2 >= 100) { + uint32_t c = (sig2 % 100) << 1; + sig2 /= 100; + copy_two_digs(p - 2, Digits + c); + p -= 2; + } + if (sig2 >= 10) { + uint32_t c = sig2 << 1; + copy_two_digs(p - 2, Digits + c); + } else { + *out = (char) ('0' + sig2); + } + return out + cnt - ctz; +} + +static always_inline char* format_integer(uint64_t sig, char *out, unsigned cnt) { + char *p = out + cnt; + if ((sig >> 32) != 0) { + uint64_t q = sig / 100000000; + uint32_t r = ((uint32_t)sig) - 100000000 * ((uint32_t) q); + sig = q; + uint32_t c = r % 10000; + r /= 10000; + uint32_t d = r % 10000; + uint32_t c0 = (c % 100) << 1; + uint32_t c1 = (c / 100) << 1; + uint32_t d0 = (d % 100) << 1; + uint32_t d1 = (d / 100) << 1; + copy_two_digs(p - 2, Digits + c0); + copy_two_digs(p - 4, Digits + c1); + copy_two_digs(p - 6, Digits + d0); + copy_two_digs(p - 8, Digits + d1); + p -= 8; + } + + uint32_t sig2 = (uint32_t)sig; + while (sig2 >= 10000) { + uint32_t c = sig2 - 10000 * (sig2 / 10000); + sig2 /= 10000; + uint32_t c0 = (c % 100) << 1; + uint32_t c1 = (c / 100) << 1; + copy_two_digs(p - 2, Digits + c0); + copy_two_digs(p - 4, Digits + c1); + p -= 4; + } + if (sig2 >= 100) { + uint32_t c = (sig2 % 100) << 1; + sig2 /= 100; + copy_two_digs(p - 2, Digits + c); + p -= 2; + } + if (sig2 >= 10) { + uint32_t c = sig2 << 1; + copy_two_digs(p - 2, Digits + c); + } else { + *out = (char) ('0' + sig2); + } + return out + cnt; +} + +static always_inline char* format_exponent(f64_dec v, char *out, unsigned cnt) { + char* p = out + 1; + char* end = format_significand(v.sig, p, cnt); + while (*(end - 1) == '0') end--; + + /* print decimal point if needed */ + *out = *p; + if (end - p > 1) { + *p = '.'; + } else { + end--; + } + + /* print the exponent */ + *end++ = 'e'; + int32_t exp = v.exp + (int32_t) cnt - 1; + if (exp < 0) { + *end++ = '-'; + exp = -exp; + } else { + *end++ = '+'; + } + + if (exp >= 100) { + int32_t c = exp % 10; + copy_two_digs(end, Digits + 2 * (exp / 10)); + end[2] = (char) ('0' + c); + end += 3; + } else if (exp >= 10) { + copy_two_digs(end, Digits + 2 * exp); + end += 2; + } else { + *end++ = (char) ('0' + exp); + } + return end; +} + +static always_inline char* format_decimal(f64_dec v, char* out, unsigned cnt) { + char* p = out; + char* end; + int point = cnt + v.exp; + + /* print leading zeros if fp < 1 */ + if (point <= 0) { + *p++ = '0', *p++ = '.'; + for (int i = 0; i < -point; i++) { + *p++ = '0'; + } + } + + /* add the remaining digits */ + end = format_significand(v.sig, p, cnt); + while (*(end - 1) == '0') end--; + if (point <= 0) { + return end; + } + + /* insert point or add trailing zeros */ + int digs = end - p; + if (digs > point) { + for (int i = 0; i < digs - point; i++) { + *(end - i) = *(end - i - 1); + } + p[point] = '.'; + end++; + } else { + for (int i = 0; i < point - digs; i++) { + *end++ = '0'; + } + } + return end; +} + +static always_inline char* write_dec(f64_dec dec, char* p) { + int cnt = ctz10(dec.sig); + int dot = cnt + dec.exp; + int sci_exp = dot - 1; + bool exp_fmt = sci_exp < -6 || sci_exp > 20; + bool has_dot = dot < cnt; + + if (exp_fmt) { + return format_exponent(dec, p, cnt); + } + if (has_dot) { + return format_decimal(dec, p, cnt); + } + + char* end = p + dot; + p = format_integer(dec.sig, p, cnt); + while (p < end) *p++ = '0'; + return end; +} + +static always_inline uint64_t f64toraw(double fp) { + union { + uint64_t u64; + double f64; + } uval; + uval.f64 = fp; + return uval.u64; +} + +static always_inline uint64_t round_odd(uint64x2 g, uint64_t cp) { + const uint128_t x = ((uint128_t)cp) * g.lo; + const uint128_t y = ((uint128_t)cp) * g.hi + ((uint64_t)(x >> 64)); + + const uint64_t y0 = ((uint64_t)y); + const uint64_t y1 = ((uint64_t)(y >> 64)); + return y1 | (y0 > 1); +} + +/** + Rendering float point number into decimal. + The function used Schubfach algorithm, reference: + The Schubfach way to render doubles, Raffaello Giulietti, 2022-03-20. + https://drive.google.com/file/d/1gp5xv4CAa78SVgCeWfGqqI4FfYYYuNFb + https://mail.openjdk.java.net/pipermail/core-libs-dev/2021-November/083536.html + https://github.com/openjdk/jdk/pull/3402 (Java implementation) + https://github.com/abolz/Drachennest (C++ implementation) + */ +static always_inline f64_dec f64todec(uint64_t rsig, int32_t rexp, uint64_t c, int32_t q) { + uint64_t cbl, cb, cbr, vbl, vb, vbr, lower, upper, s; + int32_t k, h; + bool even, irregular, w_inside, u_inside; + f64_dec dec; + + even = !(c & 1); + irregular = rsig == 0 && rexp > 1; + + cbl = 4 * c - 2 + irregular; + cb = 4 * c; + cbr = 4 * c + 2; + + /* q is in [-1500, 1500] + k = irregular ? floor(log_10(3/4 * 2^q)) : floor(log10(pow(2^q))) + floor(log10(3/4 * 2^q)) = (q * 1262611 - 524031) >> 22 + floor(log10(pow(2^q))) = (q * 1262611) >> 22 */ + k = (q * 1262611 - (irregular ? 524031 : 0)) >> 22; + + /* k is in [-1233, 1233] + s = floor(V) = floor(c * 2^q * 10^-k) + vb = 4V = 4 * c * 2^q * 10^-k */ + h = q + ((-k) * 1741647 >> 19) + 1; + uint64x2 pow10 = pow10_ceil_sig(-k); + vbl = round_odd(pow10, cbl << h); + vb = round_odd(pow10, cb << h); + vbr = round_odd(pow10, cbr << h); + + lower = vbl + !even; + upper = vbr - !even; + + s = vb / 4; + if (s >= 10) { + /* R_k+1 interval contains at most one: up or wp */ + uint64_t sp = s / 10; + bool up_inside = lower <= (40 * sp); + bool wp_inside = (40 * sp + 40) <= upper; + if (up_inside != wp_inside) { + dec.sig = sp + wp_inside; + dec.exp = k + 1; + return dec; + } + } + + /* R_k interval contains at least one: u or w */ + u_inside = lower <= (4 * s); + w_inside = (4 * s + 4) <= upper; + if (u_inside != w_inside) { + dec.sig = s + w_inside; + dec.exp = k; + return dec; + } + + /* R_k interval contains both u or w */ + uint64_t mid = 4 * s + 2; + bool round_up = vb > mid || (vb == mid && (s & 1) != 0); + dec.sig = s + round_up; + dec.exp = k; + return dec; +} + +int f64toa(char *out, double fp) { + char* p = out; + uint64_t raw = f64toraw(fp); + bool neg; + uint64_t rsig, c; + int32_t rexp, q; + + neg = ((raw >> (F64_BITS - 1)) != 0); + rsig = raw & F64_SIG_MASK; + rexp = (int32_t)((raw & F64_EXP_MASK) >> F64_SIG_BITS); + + /* check infinity and nan */ + if (unlikely(rexp == F64_INF_NAN_EXP)) { + return 0; + } + + /* check negative numbers */ + *p = '-'; + p += neg; + + /* simple case of 0.0 */ + if ((raw << 1) == 0) { + *p++ = '0'; + return p - out; + } + + /* fp = c * 2^q */ + if (likely(rexp != 0)) { + /* double is normal */ + c = rsig | F64_HIDDEN_BIT; + q = rexp - F64_EXP_BIAS - F64_SIG_BITS; + + /* fast path for integer */ + if (q <= 0 && q >= -F64_SIG_BITS && is_div_pow2(c, -q)) { + uint64_t u = c >> -q; + p = format_integer(u, p, ctz10(u)); + return p - out; + } + + } else { + c = rsig; + q = 1 - F64_EXP_BIAS - F64_SIG_BITS; + } + + f64_dec dec = f64todec(rsig, rexp, c, q); + p = write_dec(dec, p); + return p - out; +} + +#undef F64_BITS +#undef F64_EXP_BITS +#undef F64_SIG_BITS +#undef F64_EXP_MASK +#undef F64_SIG_MASK +#undef F64_EXP_BIAS +#undef F64_INF_NAN_EXP +#undef F64_HIDDEN_BIT diff --git a/native/arm/fastint.h b/native/arm/fastint.h new file mode 100644 index 000000000..f26d6940c --- /dev/null +++ b/native/arm/fastint.h @@ -0,0 +1,232 @@ +/* + * 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. + */ +#pragma once + +#include "native.h" +#include "tab.h" + +static const char Vec16xA0[16] __attribute__((aligned(16))) = { + '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0', +}; + +static const uint16_t Vec8x10[8] __attribute__((aligned(16))) = { + 10, 10, 10, 10, + 10, 10, 10, 10, +}; + +static const uint32_t Vec4x10k[4] __attribute__((aligned(16))) = { + 10000, + 10000, + 10000, + 10000, +}; + +static const uint32_t Vec4xDiv10k[4] __attribute__((aligned(16))) = { + 0xd1b71759, + 0xd1b71759, + 0xd1b71759, + 0xd1b71759, +}; + +static const uint16_t VecDivPowers[8] __attribute__((aligned(16))) = { + 0x20c5, 0x147b, + 0x3334, 0x8000, + 0x20c5, 0x147b, + 0x3334, 0x8000, +}; + +static const uint16_t VecShiftPowers[8] __attribute__((aligned(16))) = { + 0x0080, 0x0800, + 0x2000, 0x8000, + 0x0080, 0x0800, + 0x2000, 0x8000, +}; + +static const uint8_t VecShiftShuffles[144] __attribute__((aligned(16))) = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, + 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, + 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, + 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, + 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static always_inline int itoa1(char *out, int n, uint32_t v) { + out[n++] = (char)v + '0'; + return n; +} + +static always_inline int itoa2(char *out, int n, uint32_t v) { + out[n++] = Digits[v]; + out[n++] = Digits[v + 1]; + return n; +} + +static always_inline __m128i itoa8_sse2(uint32_t v) { + __m128i v00 = _mm_cvtsi32_si128 (v); + __m128i v01 = _mm_mul_epu32 (v00, as_m128v(Vec4xDiv10k)); + __m128i v02 = _mm_srli_epi64 (v01, 45); + __m128i v03 = _mm_mul_epu32 (v02, as_m128v(Vec4x10k)); + __m128i v04 = _mm_sub_epi32 (v00, v03); + __m128i v05 = _mm_unpacklo_epi16 (v02, v04); + __m128i v06 = _mm_slli_epi64 (v05, 2); + __m128i v07 = _mm_unpacklo_epi16 (v06, v06); + __m128i v08 = _mm_unpacklo_epi32 (v07, v07); + __m128i v09 = _mm_mulhi_epu16 (v08, as_m128v(VecDivPowers)); + __m128i v10 = _mm_mulhi_epu16 (v09, as_m128v(VecShiftPowers)); + __m128i v11 = _mm_mullo_epi16 (v10, as_m128v(Vec8x10)); + __m128i v12 = _mm_slli_epi64 (v11, 16); + __m128i v13 = _mm_sub_epi16 (v10, v12); + return v13; +} + +static always_inline int u32toa_small(char *out, uint32_t val) { + int n = 0; + uint32_t d1 = (val / 100) << 1; + uint32_t d2 = (val % 100) << 1; + + /* 1000-th digit */ + if (val >= 1000) { + out[n++] = Digits[d1]; + } + + /* 100-th digit */ + if (val >= 100) { + out[n++] = Digits[d1 + 1]; + } + + /* 10-th digit */ + if (val >= 10) { + out[n++] = Digits[d2]; + } + + /* last digit */ + out[n++] = Digits[d2 + 1]; + return n; +} + +static always_inline int u32toa_medium(char *out, uint32_t val) { + int n = 0; + uint32_t b = val / 10000; + uint32_t c = val % 10000; + uint32_t d1 = (b / 100) << 1; + uint32_t d2 = (b % 100) << 1; + uint32_t d3 = (c / 100) << 1; + uint32_t d4 = (c % 100) << 1; + + /* 10000000-th digit */ + if (val >= 10000000) { + out[n++] = Digits[d1]; + } + + /* 1000000-th digit */ + if (val >= 1000000) { + out[n++] = Digits[d1 + 1]; + } + + /* 100000-th digit */ + if (val >= 100000) { + out[n++] = Digits[d2]; + } + + /* remaining digits */ + out[n++] = Digits[d2 + 1]; + out[n++] = Digits[d3]; + out[n++] = Digits[d3 + 1]; + out[n++] = Digits[d4]; + out[n++] = Digits[d4 + 1]; + return n; +} + +static always_inline int u64toa_large_sse2(char *out, uint64_t val) { + uint32_t a = (uint32_t)(val / 100000000); + uint32_t b = (uint32_t)(val % 100000000); + + /* convert to digits */ + __m128i v0 = itoa8_sse2(a); + __m128i v1 = itoa8_sse2(b); + + /* convert to bytes, add '0' */ + __m128i v2 = _mm_packus_epi16 (v0, v1); + __m128i v3 = _mm_add_epi8 (v2, as_m128v(Vec16xA0)); + + /* count number of digit */ + __m128i v4 = _mm_cmpeq_epi8 (v3, as_m128v(Vec16xA0)); + uint32_t bm = _mm_movemask_epi8 (v4); + uint32_t nd = __builtin_ctz (~bm | 0x8000); + + /* shift digits to the beginning */ + __m128i p = _mm_loadu_si128 (as_m128c(&VecShiftShuffles[nd * 16])); + __m128i r = _mm_shuffle_epi8 (v3, p); + + /* store the result */ + _mm_storeu_si128(as_m128p(out), r); + return 16 - nd; +} + +static always_inline int u64toa_xlarge_sse2(char *out, uint64_t val) { + int n = 0; + uint64_t b = val % 10000000000000000; + uint32_t a = (uint32_t)(val / 10000000000000000); + + /* the highest 4 digits */ + if (a < 10) { + n = itoa1(out, n, a); + } else if (a < 100) { + n = itoa2(out, n, a << 1); + } else if (a < 1000) { + n = itoa1(out, n, a / 100); + n = itoa2(out, n, (a % 100) << 1); + } else { + n = itoa2(out, n, (a / 100) << 1); + n = itoa2(out, n, (a % 100) << 1); + } + + /* remaining digits */ + __m128i v0 = itoa8_sse2 ((uint32_t)(b / 100000000)); + __m128i v1 = itoa8_sse2 ((uint32_t)(b % 100000000)); + __m128i v2 = _mm_packus_epi16 (v0, v1); + __m128i v3 = _mm_add_epi8 (v2, as_m128v(Vec16xA0)); + + /* convert to bytes, add '0' */ + _mm_storeu_si128(as_m128p(&out[n]), v3); + return n + 16; +} +static INLINE_FOR_ARM int u64toa_1(char *out, uint64_t val) { + if (likely(val < 10000)) { + return u32toa_small(out, (uint32_t)val); + } else if (likely(val < 100000000)) { + return u32toa_medium(out, (uint32_t)val); + } else if (likely(val < 10000000000000000)) { + return u64toa_large_sse2(out, val); + } else { + return u64toa_xlarge_sse2(out, val); + } +} + +static INLINE_FOR_ARM int i64toa_1(char *out, int64_t val) { + if (likely(val >= 0)) { + return u64toa_1(out, (uint64_t)val); + } else { + *out = '-'; + return u64toa_1(out + 1, (uint64_t)(-val)) + 1; + } +} + diff --git a/native/arm/get_by_path.c b/native/arm/get_by_path.c new file mode 100644 index 000000000..75a844714 --- /dev/null +++ b/native/arm/get_by_path.c @@ -0,0 +1,105 @@ +#include "scanning.h" + +long get_by_path(const GoString *src, long *p, const GoSlice *path, StateMachine* sm) { + GoIface *ps = (GoIface*)(path->buf); + GoIface *pe = (GoIface*)(path->buf) + path->len; + char c = 0; + int64_t index; + long found; + +query: + /* to be safer for invalid json, use slower skip for the demanded fields */ + if (ps == pe) { + return skip_one_1(src, p, sm, 0); + } + + /* match type: should query key in object, query index in array */ + c = advance_ns(src, p); + if (is_str(ps)) { + if (c != '{') { + goto err_inval; + } + goto skip_in_obj; + } else if (is_int(ps)) { + if (c != '[') { + goto err_inval; + } + + index = get_int(ps); + if (index < 0) { + goto err_path; + } + + goto skip_in_arr; + } else { + goto err_path; + } + +skip_in_obj: + c = advance_ns(src, p); + if (c == '}') { + goto not_found; + } + if (c != '"') { + goto err_inval; + } + + /* parse the object key */ + found = match_key(src, p, get_str(ps)); + if (found < 0) { + return found; // parse string errors + } + + /* value should after : */ + c = advance_ns(src, p); + if (c != ':') { + goto err_inval; + } + if (found) { + ps++; + goto query; + } + + /* skip the unknown fields */ + skip_one_fast_1(src, p); + c = advance_ns(src, p); + if (c == '}') { + goto not_found; + } + if (c != ',') { + goto err_inval; + } + goto skip_in_obj; + +skip_in_arr: + /* check empty array */ + c = advance_ns(src, p); + if (c == ']') { + goto not_found; + } + *p -= 1; + + /* skip array elem one by one */ + while (index-- > 0) { + skip_one_fast_1(src, p); + c = advance_ns(src, p); + if (c == ']') { + goto not_found; + } + if (c != ',') { + goto err_inval; + } + } + ps++; + goto query; + +not_found: + *p -= 1; // backward error position + return -ERR_NOT_FOUND; +err_inval: + *p -= 1; + return -ERR_INVAL; +err_path: + *p -= 1; + return -ERR_UNSUPPORT_TYPE; +} \ No newline at end of file diff --git a/native/arm/html_escape.c b/native/arm/html_escape.c new file mode 100644 index 000000000..e6925d1b2 --- /dev/null +++ b/native/arm/html_escape.c @@ -0,0 +1,77 @@ + +#include "parsing.h" + +ssize_t html_escape(const char *sp, ssize_t nb, char *dp, ssize_t *dn) { + ssize_t nd = *dn; + const char * ds = dp; + const char * ss = sp; + const quoted_t * tab = _HtmlQuoteTab; + + /* find the special characters, copy on the fly */ + while (nb > 0) { + int nc = 0; + uint8_t ch = 0; + ssize_t rb = 0; + const char * cur = 0; + + /* not enough buffer space */ + if (nd <= 0) { + return -(sp - ss) - 1; + } + + /* find and copy */ + if ((rb = memcchr_html_quote(sp, nb, dp, nd)) < 0) { + *dn = dp - ds - rb - 1; + return -(sp - ss - rb - 1) - 1; + } + + /* skip already copied bytes */ + sp += rb; + dp += rb; + nb -= rb; + nd -= rb; + + /* stop if already finished */ + if (nb <= 0) { + break; + } + + /* mark cur postion */ + cur = sp; + + /* check for \u2028 and \u2029, binary is \xe2\x80\xa8 and \xe2\x80\xa9 */ + if (unlikely(*sp == '\xe2')) { + if (nb >= 3 && *(sp+1) == '\x80' && (*(sp+2) == '\xa8' || *(sp+2) == '\xa9')) { + sp += 2, nb -= 2; + } else if (nd > 0) { + *dp++ = *sp++; + nb--, nd--; + continue; + } else { + return -(sp - ss) - 1; + } + } + + /* get the escape entry, handle consecutive quotes */ + ch = * (uint8_t*) sp; + nc = tab[ch].n; + + + /* check for buffer space */ + if (nd < nc) { + *dn = dp - ds; + return -(cur - ss) - 1; + } + + /* copy the quoted value */ + memcpy_p8(dp, tab[ch].s, nc); + sp++; + nb--; + dp += nc; + nd -= nc; + } + + /* all done */ + *dn = dp - ds; + return sp - ss; +} diff --git a/native/arm/i64toa.c b/native/arm/i64toa.c new file mode 100644 index 000000000..a540b99d4 --- /dev/null +++ b/native/arm/i64toa.c @@ -0,0 +1,6 @@ +#include "fastint.h" + + +int i64toa(char *out, int64_t val) { + return i64toa_1(out, val); +} \ No newline at end of file diff --git a/native/arm/lspace.c b/native/arm/lspace.c new file mode 100644 index 000000000..bd184ee9f --- /dev/null +++ b/native/arm/lspace.c @@ -0,0 +1,22 @@ +/* + * 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 "native.h" +#include "lspace.h" + +size_t lspace(const char *sp, size_t nb, size_t p) { + return lspace_1(sp, nb, p); +} diff --git a/native/arm/lspace.h b/native/arm/lspace.h new file mode 100644 index 000000000..b5bbc7909 --- /dev/null +++ b/native/arm/lspace.h @@ -0,0 +1,64 @@ +/* + * 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. + */ + +#pragma once + +#include "native.h" + +static INLINE_FOR_ARM size_t lspace_1(const char *sp, size_t nb, size_t p) { + const char * ss = sp; + + /* seek to `p` */ + sp += p; + nb -= p; + + /* likely to run into non-spaces within a few characters, try scalar code first */ +#if USE_AVX2 + __m256i space_tab = _mm256_setr_epi8( + '\x20', 0, 0, 0, 0, 0, 0, 0, + 0, '\x09', '\x0A', 0, 0, '\x0D', 0, 0, + '\x20', 0, 0, 0, 0, 0, 0, 0, + 0, '\x09', '\x0A', 0, 0, '\x0D', 0, 0 + ); + + /* 32-byte loop */ + while (likely(nb >= 32)) { + __m256i input = _mm256_loadu_si256((__m256i*)sp); + __m256i shuffle = _mm256_shuffle_epi8(space_tab, input); + __m256i result = _mm256_cmpeq_epi8(input, shuffle); + int32_t mask = _mm256_movemask_epi8(result); + if (mask != -1) { + return sp - ss + __builtin_ctzll(~(uint64_t)mask); + } + sp += 32; + nb -= 32; + } +#endif + + /* remaining bytes, do with scalar code */ + while (nb-- > 0) { + switch (*sp++) { + case ' ' : break; + case '\r' : break; + case '\n' : break; + case '\t' : break; + default : return sp - ss - 1; + } + } + + /* all the characters are spaces */ + return sp - ss; +} diff --git a/native/arm/native.h b/native/arm/native.h new file mode 100644 index 000000000..a9e56c1aa --- /dev/null +++ b/native/arm/native.h @@ -0,0 +1,175 @@ +/* + * 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. + */ + +#ifndef NATIVE_H +#define NATIVE_H + +#ifdef __aarch64__ +#define SIMDE_ENABLE_NATIVE_ALIASES +#include +#include +#include +#include +#include +#include +#include +#else +#include +#endif + +#include +#include +#include + +#include "types.h" + +#define likely(v) (__builtin_expect((v), 1)) +#define unlikely(v) (__builtin_expect((v), 0)) +#define always_inline inline __attribute__((always_inline)) + +#define as_m128p(v) ((__m128i *)(v)) +#define as_m128c(v) ((const __m128i *)(v)) +#define as_m256c(v) ((const __m256i *)(v)) +#define as_m128v(v) (*(const __m128i *)(v)) +#define as_uint64v(p) (*(uint64_t *)(p)) +#define is_infinity(v) ((as_uint64v(&v) << 1) == 0xFFE0000000000000) + +#ifndef INLINE_FOR_ARM +// All functions should be inlined because the position of LR in clang frame +// is different from go. +#if __aarch64__ +#define INLINE_FOR_ARM always_inline +#else +#define INLINE_FOR_ARM +#endif +#endif + +typedef struct { + void * buf; + size_t len; + size_t cap; +} GoSlice; + +static const uint8_t GO_KIND_MASK = (1 << 5) - 1; +typedef enum { + Invalid = 0, + Bool, + Int, + Int8, + Int16, + Int32, + Int64, + Uint, + Uint8, + Uint16, + Uint32, + Uint64, + Uintptr, + Float32, + Float64, + Complex64, + Complex128, + Array, + Chan, + Func, + Interface, + Map, + Pointer, + Slice, + String, + Struct, + UnsafePointer, +} GoKind; + +typedef struct { + uint64_t size; + uint64_t ptr_data; + uint32_t hash; + uint8_t flags; + uint8_t align; + uint8_t filed_align; + uint8_t kind_flags; + uint64_t traits; + void* gc_data; + int32_t str; + int32_t ptr_to_self; +} GoType; + +typedef struct { + GoType * type; + void * value; +} GoIface; + +typedef struct { + const char * buf; + size_t len; +} GoString; + +typedef struct { + long t; + double d; + int64_t i; +} JsonNumber; + +typedef struct { + long vt; + double dv; + int64_t iv; + int64_t ep; + char* dbuf; + ssize_t dcap; +} JsonState; + +typedef struct { + int64_t sp; + int64_t vt[MAX_RECURSE]; +} StateMachine; + +int f32toa(char *out, float val); +int f64toa(char *out, double val); +int i64toa(char *out, int64_t val); +int u64toa(char *out, uint64_t val); + +size_t lspace(const char *sp, size_t nb, size_t p); + +ssize_t quote(const char *sp, ssize_t nb, char *dp, ssize_t *dn, uint64_t flags); +ssize_t unquote(const char *sp, ssize_t nb, char *dp, ssize_t *ep, uint64_t flags); +ssize_t html_escape(const char *sp, ssize_t nb, char *dp, ssize_t *dn); + +long value(const char *s, size_t n, long p, JsonState *ret, uint64_t flags); +void vstring(const GoString *src, long *p, JsonState *ret, uint64_t flags); +void vnumber(const GoString *src, long *p, JsonState *ret); +void vsigned(const GoString *src, long *p, JsonState *ret); +void vunsigned(const GoString *src, long *p, JsonState *ret); + +long skip_one(const GoString *src, long *p, StateMachine *m, uint64_t flags); +long skip_array(const GoString *src, long *p, StateMachine *m, uint64_t flags); +long skip_object(const GoString *src, long *p, StateMachine *m, uint64_t flags); + +long skip_string(const GoString *src, long *p, uint64_t flags); +long skip_negative(const GoString *src, long *p); +long skip_positive(const GoString *src, long *p); +long skip_number(const GoString *src, long *p); +long fsm_exec(StateMachine *self, const GoString *src, long *p, uint64_t flags); + +long validate_string(const GoString *src, long *p); +long validate_one(const GoString *src, long *p, StateMachine *m); +long validate_utf8(const GoString *src, long *p, StateMachine *m); +long validate_utf8_fast(const GoString *src); + +long skip_one_fast(const GoString *src, long *p); +long get_by_path(const GoString *src, long *p, const GoSlice *path, StateMachine* sm); +#endif diff --git a/native/arm/parsing.h b/native/arm/parsing.h new file mode 100644 index 000000000..f3f188574 --- /dev/null +++ b/native/arm/parsing.h @@ -0,0 +1,713 @@ +/* + * 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. + */ + +#pragma once + +#include "native.h" +#include "utils.h" +#include + +/** String Quoting **/ +#define MAX_ESCAPED_BYTES 8 +typedef struct { + const long n; + const char s[MAX_ESCAPED_BYTES]; +} quoted_t; + +static const quoted_t _SingleQuoteTab[256] = { + ['\x00'] = { .n = 6, .s = "\\u0000" }, + ['\x01'] = { .n = 6, .s = "\\u0001" }, + ['\x02'] = { .n = 6, .s = "\\u0002" }, + ['\x03'] = { .n = 6, .s = "\\u0003" }, + ['\x04'] = { .n = 6, .s = "\\u0004" }, + ['\x05'] = { .n = 6, .s = "\\u0005" }, + ['\x06'] = { .n = 6, .s = "\\u0006" }, + ['\x07'] = { .n = 6, .s = "\\u0007" }, + ['\b' ] = { .n = 6, .s = "\\u0008" }, + ['\t' ] = { .n = 2, .s = "\\t" }, + ['\n' ] = { .n = 2, .s = "\\n" }, + ['\x0b'] = { .n = 6, .s = "\\u000b" }, + ['\f' ] = { .n = 6, .s = "\\u000c" }, + ['\r' ] = { .n = 2, .s = "\\r" }, + ['\x0e'] = { .n = 6, .s = "\\u000e" }, + ['\x0f'] = { .n = 6, .s = "\\u000f" }, + ['\x10'] = { .n = 6, .s = "\\u0010" }, + ['\x11'] = { .n = 6, .s = "\\u0011" }, + ['\x12'] = { .n = 6, .s = "\\u0012" }, + ['\x13'] = { .n = 6, .s = "\\u0013" }, + ['\x14'] = { .n = 6, .s = "\\u0014" }, + ['\x15'] = { .n = 6, .s = "\\u0015" }, + ['\x16'] = { .n = 6, .s = "\\u0016" }, + ['\x17'] = { .n = 6, .s = "\\u0017" }, + ['\x18'] = { .n = 6, .s = "\\u0018" }, + ['\x19'] = { .n = 6, .s = "\\u0019" }, + ['\x1a'] = { .n = 6, .s = "\\u001a" }, + ['\x1b'] = { .n = 6, .s = "\\u001b" }, + ['\x1c'] = { .n = 6, .s = "\\u001c" }, + ['\x1d'] = { .n = 6, .s = "\\u001d" }, + ['\x1e'] = { .n = 6, .s = "\\u001e" }, + ['\x1f'] = { .n = 6, .s = "\\u001f" }, + ['"' ] = { .n = 2, .s = "\\\"" }, + ['\\' ] = { .n = 2, .s = "\\\\" }, +}; + +static const quoted_t _DoubleQuoteTab[256] = { + ['\x00'] = { .n = 7, .s = "\\\\u0000" }, + ['\x01'] = { .n = 7, .s = "\\\\u0001" }, + ['\x02'] = { .n = 7, .s = "\\\\u0002" }, + ['\x03'] = { .n = 7, .s = "\\\\u0003" }, + ['\x04'] = { .n = 7, .s = "\\\\u0004" }, + ['\x05'] = { .n = 7, .s = "\\\\u0005" }, + ['\x06'] = { .n = 7, .s = "\\\\u0006" }, + ['\x07'] = { .n = 7, .s = "\\\\u0007" }, + ['\b' ] = { .n = 7, .s = "\\\\u0008" }, + ['\t' ] = { .n = 3, .s = "\\\\t" }, + ['\n' ] = { .n = 3, .s = "\\\\n" }, + ['\x0b'] = { .n = 7, .s = "\\\\u000b" }, + ['\f' ] = { .n = 7, .s = "\\\\u000c" }, + ['\r' ] = { .n = 3, .s = "\\\\r" }, + ['\x0e'] = { .n = 7, .s = "\\\\u000e" }, + ['\x0f'] = { .n = 7, .s = "\\\\u000f" }, + ['\x10'] = { .n = 7, .s = "\\\\u0010" }, + ['\x11'] = { .n = 7, .s = "\\\\u0011" }, + ['\x12'] = { .n = 7, .s = "\\\\u0012" }, + ['\x13'] = { .n = 7, .s = "\\\\u0013" }, + ['\x14'] = { .n = 7, .s = "\\\\u0014" }, + ['\x15'] = { .n = 7, .s = "\\\\u0015" }, + ['\x16'] = { .n = 7, .s = "\\\\u0016" }, + ['\x17'] = { .n = 7, .s = "\\\\u0017" }, + ['\x18'] = { .n = 7, .s = "\\\\u0018" }, + ['\x19'] = { .n = 7, .s = "\\\\u0019" }, + ['\x1a'] = { .n = 7, .s = "\\\\u001a" }, + ['\x1b'] = { .n = 7, .s = "\\\\u001b" }, + ['\x1c'] = { .n = 7, .s = "\\\\u001c" }, + ['\x1d'] = { .n = 7, .s = "\\\\u001d" }, + ['\x1e'] = { .n = 7, .s = "\\\\u001e" }, + ['\x1f'] = { .n = 7, .s = "\\\\u001f" }, + ['"' ] = { .n = 4, .s = "\\\\\\\"" }, + ['\\' ] = { .n = 4, .s = "\\\\\\\\" }, +}; + +static const quoted_t _HtmlQuoteTab[256] = { + ['<'] = { .n = 6, .s = "\\u003c" }, + ['>'] = { .n = 6, .s = "\\u003e" }, + ['&'] = { .n = 6, .s = "\\u0026" }, + // \u2028 and \u2029 is [E2 80 A8] and [E2 80 A9] + [0xe2] = { .n = 0, .s = {0} }, + [0xa8] = { .n = 6, .s = "\\u2028" }, + [0xa9] = { .n = 6, .s = "\\u2029" }, +}; + +static always_inline __m128i _mm_find_quote(__m128i vv) { + __m128i e1 = _mm_cmpgt_epi8 (vv, _mm_set1_epi8(-1)); + __m128i e2 = _mm_cmpgt_epi8 (vv, _mm_set1_epi8(31)); + __m128i e3 = _mm_cmpeq_epi8 (vv, _mm_set1_epi8('"')); + __m128i e4 = _mm_cmpeq_epi8 (vv, _mm_set1_epi8('\\')); + __m128i r1 = _mm_andnot_si128 (e2, e1); + __m128i r2 = _mm_or_si128 (e3, e4); + __m128i rv = _mm_or_si128 (r1, r2); + return rv; +} + +#if USE_AVX2 +static always_inline __m256i _mm256_find_quote(__m256i vv) { + __m256i e1 = _mm256_cmpgt_epi8 (vv, _mm256_set1_epi8(-1)); + __m256i e2 = _mm256_cmpgt_epi8 (vv, _mm256_set1_epi8(31)); + __m256i e3 = _mm256_cmpeq_epi8 (vv, _mm256_set1_epi8('"')); + __m256i e4 = _mm256_cmpeq_epi8 (vv, _mm256_set1_epi8('\\')); + __m256i r1 = _mm256_andnot_si256 (e2, e1); + __m256i r2 = _mm256_or_si256 (e3, e4); + __m256i rv = _mm256_or_si256 (r1, r2); + return rv; +} +#endif + +static always_inline ssize_t memcchr_quote(const char *sp, ssize_t nb, char *dp, ssize_t dn) { + uint32_t mm; + const char * ss = sp; + +#if USE_AVX2 + /* 32-byte loop, full store */ + while (nb >= 32 && dn >= 32) { + __m256i vv = _mm256_loadu_si256 ((const void *)sp); + __m256i rv = _mm256_find_quote (vv); + _mm256_storeu_si256 ((void *)dp, vv); + + /* check for matches */ + if ((mm = _mm256_movemask_epi8(rv)) != 0) { + return sp - ss + __builtin_ctz(mm); + } + + /* move to next block */ + sp += 32; + dp += 32; + nb -= 32; + dn -= 32; + } + + /* 32-byte test, partial store */ + if (nb >= 32) { + __m256i vv = _mm256_loadu_si256 ((const void *)sp); + __m256i rv = _mm256_find_quote (vv); + uint32_t mv = _mm256_movemask_epi8 (rv); + uint32_t fv = __builtin_ctzll ((uint64_t)mv | 0x0100000000); + + /* copy at most `dn` characters */ + if (fv <= dn) { + memcpy_p32(dp, sp, fv); + return sp - ss + fv; + } else { + memcpy_p32(dp, sp, dn); + return -(sp - ss + dn) - 1; + } + } + + /* clear upper half to avoid AVX-SSE transition penalty */ + _mm256_zeroupper(); +#endif + + /* 16-byte loop, full store */ + while (nb >= 16 && dn >= 16) { + __m128i vv = _mm_loadu_si128 ((const void *)sp); + __m128i rv = _mm_find_quote (vv); + _mm_storeu_si128 ((void *)dp, vv); + + /* check for matches */ + if ((mm = _mm_movemask_epi8(rv)) != 0) { + return sp - ss + __builtin_ctz(mm); + } + + /* move to next block */ + sp += 16; + dp += 16; + nb -= 16; + dn -= 16; + } + + /* 16-byte test, partial store */ + if (nb >= 16) { + __m128i vv = _mm_loadu_si128 ((const void *)sp); + __m128i rv = _mm_find_quote (vv); + uint32_t mv = _mm_movemask_epi8 (rv); + uint32_t fv = __builtin_ctz (mv | 0x010000); + + /* copy at most `dn` characters */ + if (fv <= dn) { + memcpy_p16(dp, sp, fv); + return sp - ss + fv; + } else { + memcpy_p16(dp, sp, dn); + return -(sp - ss + dn) - 1; + } + } + + /* handle the remaining bytes with scalar code */ + while (nb > 0 && dn > 0) { + if (_SingleQuoteTab[*(uint8_t *)sp].n) { + return sp - ss; + } else { + dn--, nb--; + *dp++ = *sp++; + } + } + + /* check for dest buffer */ + if (nb == 0) { + return sp - ss; + } else { + return -(sp - ss) - 1; + } +} + +static const bool _EscTab[256] = { + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x00-0x0F + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x10-0x1F + // '"' + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x20-0x2F + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x30-0x3F + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x40-0x4F + // '"" + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, // 0x50-0x5F + // 0x60-0xFF are zeroes +}; + +static always_inline uint8_t escape_mask4(const char *sp) { + return _EscTab[*(uint8_t *)(sp)] | (_EscTab[*(uint8_t *)(sp + 1)] << 1) | (_EscTab[*(uint8_t *)(sp + 2)] << 2) | (_EscTab[*(uint8_t *)(sp + 3)] << 3); +} + +static always_inline ssize_t memcchr_quote_unsafe(const char *sp, ssize_t nb, char *dp, const quoted_t * tab) { + uint32_t mm; + const char * ds = dp; + size_t cn = 0; + +simd_copy: + + if (nb < 16) goto scalar_copy; + +#if USE_AVX2 + /* 32-byte loop, full store */ + while (nb >= 32) { + __m256i vv = _mm256_loadu_si256 ((const void *)sp); + __m256i rv = _mm256_find_quote (vv); + _mm256_storeu_si256 ((void *)dp, vv); + + /* check for matches */ + if ((mm = _mm256_movemask_epi8(rv)) != 0) { + cn = __builtin_ctz(mm); + sp += cn; + nb -= cn; + dp += cn; + goto escape; + } + + /* move to next block */ + sp += 32; + dp += 32; + nb -= 32; + } + + /* clear upper half to avoid AVX-SSE transition penalty */ + _mm256_zeroupper(); +#endif + + /* 16-byte loop, full store */ + while (nb >= 16) { + __m128i vv = _mm_loadu_si128 ((const void *)sp); + __m128i rv = _mm_find_quote (vv); + _mm_storeu_si128 ((void *)dp, vv); + + /* check for matches */ + if ((mm = _mm_movemask_epi8(rv)) != 0) { + cn = __builtin_ctz(mm); + sp += cn; + nb -= cn; + dp += cn; + goto escape; + } + + /* move to next block */ + sp += 16; + dp += 16; + nb -= 16; + } + + /* handle the remaining bytes with scalar code */ + // while (nb > 0) { + // if (_EscTab[*(uint8_t *)sp]) { + // goto escape; + // } else { + // nb--; + // *dp++ = *sp++; + // } + // } + // optimize: loop unrolling here + +scalar_copy: + if (nb >= 8) { + uint8_t mask1 = escape_mask4(sp); + *(uint64_t *)dp = *(const uint64_t *)sp; + if (unlikely(mask1)) { + cn = __builtin_ctz(mask1); + sp += cn; + nb -= cn; + dp += cn; + goto escape; + } + uint8_t mask2 = escape_mask4(sp + 4); + if (unlikely(mask2)) { + cn = __builtin_ctz(mask2); + sp += cn + 4; + nb -= cn + 4; + dp += cn + 4; + goto escape; + } + dp += 8, sp += 8, nb -= 8; + } + + if (nb >= 4) { + uint8_t mask2 = escape_mask4(sp); + *(uint32_t *)dp = *(const uint32_t *)sp; + if (unlikely(mask2)) { + cn = __builtin_ctz(mask2); + sp += cn; + nb -= cn; + dp += cn; + goto escape; + } + dp += 4, sp += 4, nb -= 4; + } + + while (nb > 0) { + if (unlikely(_EscTab[*(uint8_t *)(sp)])) goto escape; + *dp++ = *sp++, nb--; + } + /* all quote done */ + return dp - ds; +escape: + /* get the escape entry, handle consecutive quotes */ + do { + uint8_t ch = *(uint8_t *)sp; + int nc = tab[ch].n; + /* copy the quoted value. + * Note: dp always has at least 8 bytes (MAX_ESCAPED_BYTES) here. + * so, we not use memcpy_p8(dp, tab[ch].s, nc); + */ + *(uint64_t *)dp = *(const uint64_t *)tab[ch].s; + sp++; + nb--; + dp += nc; + if (nb <= 0) break; + /* copy and find escape chars */ + if (_EscTab[*(uint8_t *)(sp)] == 0) { + goto simd_copy; + } + } while (true); + return dp - ds; +} + +/** String Unquoting **/ + +static const char _UnquoteTab[256] = { + ['/' ] = '/', + ['"' ] = '"', + ['b' ] = '\b', + ['f' ] = '\f', + ['n' ] = '\n', + ['r' ] = '\r', + ['t' ] = '\t', + ['u' ] = -1, + ['\\'] = '\\', +}; + +static always_inline ssize_t memcchr_p32(const char *s, ssize_t nb, char *p) { + int64_t r; + ssize_t n = nb; + const char * q = s; + +#if USE_AVX2 + __m256i u; + __m256i v; + __m256i b = _mm256_set1_epi8('\\'); + + /* process every 32 bytes */ + while (n >= 32) { + u = _mm256_loadu_si256 ((const void *)s); + v = _mm256_cmpeq_epi8 (u, b); + _mm256_storeu_si256 ((void *)p, u); + + /* check for matches */ + if ((r = _mm256_movemask_epi8(v)) != 0) { + return s - q + __builtin_ctzll(r); + } + + /* move to the next 32 bytes */ + s += 32; + p += 32; + n -= 32; + } + + /* clear upper half to avoid AVX-SSE transition penalty */ + _mm256_zeroupper(); +#endif + + /* initialze with '\\' */ + __m128i x; + __m128i y; + __m128i a = _mm_set1_epi8('\\'); + + /* process every 16 bytes */ + while (n >= 16) { + x = _mm_loadu_si128 ((const void *)s); + y = _mm_cmpeq_epi8 (x, a); + _mm_storeu_si128 ((void *)p, x); + + /* check for matches */ + if ((r = _mm_movemask_epi8(y)) != 0) { + return s - q + __builtin_ctzll(r); + } + + /* move to the next 16 bytes */ + s += 16; + p += 16; + n -= 16; + } + + /* remaining bytes, do with scalar code */ + while (n--) { + if (*s != '\\') { + *p++ = *s++; + } else { + return s - q; + } + } + + /* nothing found, but everything was copied */ + return -1; +} + +#define ALL_01h (~0ul / 255) +#define ALL_7fh (ALL_01h * 127) +#define ALL_80h (ALL_01h * 128) + +static always_inline uint32_t hasless(uint32_t x, uint8_t n) { + return (x - ALL_01h * n) & ~x & ALL_80h; +} + +static always_inline uint32_t hasmore(uint32_t x, uint8_t n) { + return (x + ALL_01h * (127 - n) | x) & ALL_80h; +} + +static always_inline uint32_t hasbetween(uint32_t x, uint8_t m, uint8_t n) { + return (ALL_01h * (127 + n) - (x & ALL_7fh) & ~x & (x & ALL_7fh) + ALL_01h * (127 - m)) & ALL_80h; +} + +#undef ALL_01h +#undef ALL_7fh +#undef ALL_80h + +static always_inline char ishex(char c) { + return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'); +} + +static always_inline void unirep(char **dp) { + *(*dp)++ = 0xef; + *(*dp)++ = 0xbf; + *(*dp)++ = 0xbd; +} + +static always_inline char unhex16_is(const char *s) { + uint32_t v = *(uint32_t *)s; + return !(hasless(v, '0') || hasmore(v, 'f') || hasbetween(v, '9', 'A') || hasbetween(v, 'F', 'a')); +} + +static always_inline uint32_t unhex16_fast(const char *s) { + uint32_t a = __builtin_bswap32(*(uint32_t *)s); + uint32_t b = 9 * ((~a & 0x10101010) >> 4) + (a & 0x0f0f0f0f); + uint32_t c = (b >> 4) | b; + uint32_t d = ((c >> 8) & 0xff00) | (c & 0x00ff); + return d; +} + +static always_inline __m128i _mm_find_html(__m128i vv) { + __m128i e1 = _mm_cmpeq_epi8 (vv, _mm_set1_epi8('<')); + __m128i e2 = _mm_cmpeq_epi8 (vv, _mm_set1_epi8('>')); + __m128i e3 = _mm_cmpeq_epi8 (vv, _mm_set1_epi8('&')); + __m128i e4 = _mm_cmpeq_epi8 (vv, _mm_set1_epi8('\xe2')); + __m128i r1 = _mm_or_si128 (e1, e2); + __m128i r2 = _mm_or_si128 (e3, e4); + __m128i rv = _mm_or_si128 (r1, r2); + return rv; +} + +#if USE_AVX2 +static always_inline __m256i _mm256_find_html(__m256i vv) { + __m256i e1 = _mm256_cmpeq_epi8 (vv, _mm256_set1_epi8('<')); + __m256i e2 = _mm256_cmpeq_epi8 (vv, _mm256_set1_epi8('>')); + __m256i e3 = _mm256_cmpeq_epi8 (vv, _mm256_set1_epi8('&')); + __m256i e4 = _mm256_cmpeq_epi8 (vv, _mm256_set1_epi8('\xe2')); + __m256i r1 = _mm256_or_si256 (e1, e2); + __m256i r2 = _mm256_or_si256 (e3, e4); + __m256i rv = _mm256_or_si256 (r1, r2); + return rv; +} +#endif + +static always_inline ssize_t memcchr_html_quote(const char *sp, ssize_t nb, char *dp, ssize_t dn) { + uint32_t mm; + const char * ss = sp; + +#if USE_AVX2 + /* 32-byte loop, full store */ + while (nb >= 32 && dn >= 32) { + __m256i vv = _mm256_loadu_si256 ((const void *)sp); + __m256i rv = _mm256_find_html (vv); + _mm256_storeu_si256 ((void *)dp, vv); + + /* check for matches */ + if ((mm = _mm256_movemask_epi8(rv)) != 0) { + return sp - ss + __builtin_ctz(mm); + } + + /* move to next block */ + sp += 32; + dp += 32; + nb -= 32; + dn -= 32; + } + + /* 32-byte test, partial store */ + if (nb >= 32) { + __m256i vv = _mm256_loadu_si256 ((const void *)sp); + __m256i rv = _mm256_find_html (vv); + uint32_t mv = _mm256_movemask_epi8 (rv); + uint32_t fv = __builtin_ctzll ((uint64_t)mv | 0x0100000000); + + /* copy at most `dn` characters */ + if (fv <= dn) { + memcpy_p32(dp, sp, fv); + return sp - ss + fv; + } else { + memcpy_p32(dp, sp, dn); + return -(sp - ss + dn) - 1; + } + } + + /* clear upper half to avoid AVX-SSE transition penalty */ + _mm256_zeroupper(); +#endif + + /* 16-byte loop, full store */ + while (nb >= 16 && dn >= 16) { + __m128i vv = _mm_loadu_si128 ((const void *)sp); + __m128i rv = _mm_find_html (vv); + _mm_storeu_si128 ((void *)dp, vv); + + /* check for matches */ + if ((mm = _mm_movemask_epi8(rv)) != 0) { + return sp - ss + __builtin_ctz(mm); + } + + /* move to next block */ + sp += 16; + dp += 16; + nb -= 16; + dn -= 16; + } + + /* 16-byte test, partial store */ + if (nb >= 16) { + __m128i vv = _mm_loadu_si128 ((const void *)sp); + __m128i rv = _mm_find_html (vv); + uint32_t mv = _mm_movemask_epi8 (rv); + uint32_t fv = __builtin_ctz (mv | 0x010000); + + /* copy at most `dn` characters */ + if (fv <= dn) { + memcpy_p16(dp, sp, fv); + return sp - ss + fv; + } else { + memcpy_p16(dp, sp, dn); + return -(sp - ss + dn) - 1; + } + } + + /* handle the remaining bytes with scalar code */ + while (nb > 0 && dn > 0) { + if (*sp == '<' || *sp == '>' || *sp == '&' || *sp == '\xe2') { + return sp - ss; + } else { + dn--, nb--; + *dp++ = *sp++; + } + } + + /* check for dest buffer */ + if (nb == 0) { + return sp - ss; + } else { + return -(sp - ss) - 1; + } +} + +static always_inline long unescape(const char** src, const char* end, char* dp) { + const char* sp = *src; + long nb = end - sp; + char cc = 0; + uint32_t r0, r1; + + if (nb <= 0) return -ERR_EOF; + + if ((cc = _UnquoteTab[(uint8_t)sp[1]]) == 0) { + *src += 1; + return -ERR_ESCAPE; + } + + if (cc != -1) { + *dp = cc; + *src += 2; + return 1; + } + + if (nb < 4) { + *src += 1; + return -ERR_EOF; + } + + /* check for hexadecimal characters */ + if (!unhex16_is(sp + 2)) { + *src += 2; + return -ERR_INVAL; + } + + /* decode the code-point */ + r0 = unhex16_fast(sp + 2); + sp += 6; + *src = sp; + + /* ASCII characters, unlikely */ + if (unlikely(r0 <= 0x7f)) { + *dp++ = (char)r0; + return 1; + } + + /* latin-1 characters, unlikely */ + if (unlikely(r0 <= 0x07ff)) { + *dp++ = (char)(0xc0 | (r0 >> 6)); + *dp++ = (char)(0x80 | (r0 & 0x3f)); + return 2; + } + + /* 3-byte characters, likely */ + if (likely(r0 < 0xd800 || r0 > 0xdfff)) { + *dp++ = (char)(0xe0 | ((r0 >> 12) )); + *dp++ = (char)(0x80 | ((r0 >> 6) & 0x3f)); + *dp++ = (char)(0x80 | ((r0 ) & 0x3f)); + return 3; + } + + /* surrogate half, must follows by the other half */ + if (nb < 6 || r0 > 0xdbff || sp[0] != '\\' || sp[1] != 'u') { + return -ERR_UNICODE; + } + + /* check the hexadecimal escape */ + if (!unhex16_is(sp + 2)) { + *src += 2; + return -ERR_INVAL; + } + + /* decode the second code-point */ + r1 = unhex16_fast(sp + 2); + + /* it must be the other half */ + if (r1 < 0xdc00 || r1 > 0xdfff) { + *src += 2; + return -ERR_UNICODE; + } + + /* merge two surrogates */ + r0 = (r0 - 0xd800) << 10; + r1 = (r1 - 0xdc00) + 0x010000; + r0 += r1; + + /* encode the character */ + *dp++ = (char)(0xf0 | ((r0 >> 18) )); + *dp++ = (char)(0x80 | ((r0 >> 12) & 0x3f)); + *dp++ = (char)(0x80 | ((r0 >> 6) & 0x3f)); + *dp++ = (char)(0x80 | ((r0 ) & 0x3f)); + *src = sp + 6; + return 4; +} \ No newline at end of file diff --git a/native/arm/quote.c b/native/arm/quote.c new file mode 100644 index 000000000..4377e2f98 --- /dev/null +++ b/native/arm/quote.c @@ -0,0 +1,67 @@ +#include "parsing.h" + +ssize_t quote(const char *sp, ssize_t nb, char *dp, ssize_t *dn, uint64_t flags) { + ssize_t nd = *dn; + const char * ds = dp; + const char * ss = sp; + const quoted_t * tab; + + /* select quoting table */ + if (!(flags & F_DBLUNQ)) { + tab = _SingleQuoteTab; + } else { + tab = _DoubleQuoteTab; + } + + if (*dn >= nb * MAX_ESCAPED_BYTES) { + *dn = memcchr_quote_unsafe(sp, nb, dp, tab); + return nb; + } + + /* find the special characters, copy on the fly */ + while (nb != 0) { + int nc; + uint8_t ch; + ssize_t rb = memcchr_quote(sp, nb, dp, nd); + + /* not enough buffer space */ + if (rb < 0) { + *dn = dp - ds - rb - 1; + return -(sp - ss - rb - 1) - 1; + } + + /* skip already copied bytes */ + sp += rb; + dp += rb; + nb -= rb; + nd -= rb; + + /* get the escape entry, handle consecutive quotes */ + while (nb != 0) { + ch = *(uint8_t *)sp; + nc = tab[ch].n; + + /* check for escape character */ + if (nc == 0) { + break; + } + + /* check for buffer space */ + if (nc > nd) { + *dn = dp - ds; + return -(sp - ss) - 1; + } + + /* copy the quoted value */ + memcpy_p8(dp, tab[ch].s, nc); + sp++; + nb--; + dp += nc; + nd -= nc; + } + } + + /* all done */ + *dn = dp - ds; + return sp - ss; +} diff --git a/native/arm/scanning.h b/native/arm/scanning.h new file mode 100644 index 000000000..ae13b4bca --- /dev/null +++ b/native/arm/scanning.h @@ -0,0 +1,1736 @@ +/* + * 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. + */ + +#pragma once + +#include "native.h" +#include "utf8.h" +#include "utils.h" +#include "parsing.h" +#include "lspace.h" +#include "atof_native.h" +#include "atof_eisel_lemire.h" + +static INLINE_FOR_ARM long skip_number_1(const GoString *src, long *p); +static INLINE_FOR_ARM void vnumber_1(const GoString *src, long *p, JsonState *ret); +static INLINE_FOR_ARM long skip_string_1(const GoString *src, long *p, uint64_t flags); +static INLINE_FOR_ARM long skip_positive_1(const GoString *src, long *p); +static INLINE_FOR_ARM long skip_negative_1(const GoString *src, long *p); + +static const uint64_t ODD_MASK = 0xaaaaaaaaaaaaaaaa; +static const uint64_t EVEN_MASK = 0x5555555555555555; + +// NOTE: mask referenced from decoder/decoder.go +static const uint64_t MASK_VALIDATE_STRING = 1ull << 5; +static const uint64_t MASK_ALLOW_CONTROL = 1ull << 31; + +static const double P10_TAB[23] = { + /* <= the connvertion to double is not exact when less than 1 => */ 1e-000, + 1e+001, 1e+002, 1e+003, 1e+004, 1e+005, 1e+006, 1e+007, 1e+008, 1e+009, 1e+010, + 1e+011, 1e+012, 1e+013, 1e+014, 1e+015, 1e+016, 1e+017, 1e+018, 1e+019, 1e+020, + 1e+021, 1e+022 /* <= the connvertion to double is not exact when larger, => */ +}; + +static always_inline uint64_t add32(uint64_t v1, uint64_t v2, uint64_t *vo) { + uint32_t v; + uint32_t c = __builtin_uadd_overflow((uint32_t)v1, (uint32_t)v2, &v); + + /* set the carry */ + *vo = c; + return v; +} + +static always_inline uint64_t add64(uint64_t v1, uint64_t v2, uint64_t *vo) { + unsigned long long v; + uint64_t c = __builtin_uaddll_overflow(v1, v2, &v); + + /* set the carry */ + *vo = c; + return v; +} + +static always_inline char isspace(char ch) { + return ch == ' ' || ch == '\r' || ch == '\n' | ch == '\t'; +} + +const int MASK_USE_NUMBER = 1<<1; + +static always_inline void vdigits(const GoString *src, long *p, JsonState *ret, uint64_t flag) { + --*p; + if (flag & MASK_USE_NUMBER) { + long i = skip_number_1(src, p); + if (i < 0) { + ret->vt = i; + return; + } + ret->vt = V_DOUBLE; + ret->ep = i; + return; + } + vnumber_1(src, p, ret); +} + +static always_inline char advance_ns(const GoString *src, long *p) { + size_t vi = *p; + size_t nb = src->len; + const char * sp = src->buf; + + /* it's likely to run into non-spaces within a few + * characters, so test up to 4 characters manually */ + if (vi < nb && !isspace(sp[vi])) goto nospace; else vi++; + if (vi < nb && !isspace(sp[vi])) goto nospace; else vi++; + if (vi < nb && !isspace(sp[vi])) goto nospace; else vi++; + if (vi < nb && !isspace(sp[vi])) goto nospace; else vi++; + + /* check EOF */ + if (vi >= nb) { + *p = vi; + return 0; + } + + /* too many spaces, use SIMD to search for characters */ + if ((vi = lspace_1(sp, nb, vi)) >= nb) { + return 0; + } + +nospace: + *p = vi + 1; + return src->buf[vi]; +} + +static always_inline int64_t advance_dword(const GoString *src, long *p, long dec, int64_t ret, uint32_t val) { + if (*p > src->len + dec - 4) { + *p = src->len; + return -ERR_EOF; + } else if (*(uint32_t *)(src->buf + *p - dec) == val) { + *p += 4 - dec; + return ret; + } else { + *p -= dec; + for (int i = 0; src->buf[*p] == (val & 0xff) && i < 4; i++, ++*p) { val >>= 8; } + return -ERR_INVAL; + } +} + +static always_inline ssize_t advance_string_default(const GoString *src, long p, int64_t *ep) { + char ch; + uint64_t es; + uint64_t fe; + uint64_t os; + uint64_t m0; + uint64_t m1; + uint64_t cr = 0; + + /* prevent out-of-bounds accessing */ + if (unlikely(src->len == p)) { + return -ERR_EOF; + } + + /* buffer pointers */ + size_t nb = src->len; + const char * sp = src->buf; + const char * ss = src->buf; + +#define ep_init() *ep = -1; +#define ep_setc() ep_setx(sp - ss - 1) +#define ep_setx(x) if (*ep == -1) { *ep = (x); } + + /* seek to `p` */ + nb -= p; + sp += p; + ep_init() + +#if USE_AVX2 + /* initialize vectors */ + __m256i v0; + __m256i v1; + __m256i q0; + __m256i q1; + __m256i x0; + __m256i x1; + __m256i cq = _mm256_set1_epi8('"'); + __m256i cx = _mm256_set1_epi8('\\'); + + /* partial masks */ + uint32_t s0; + uint32_t s1; + uint32_t t0; + uint32_t t1; +#else + /* initialize vectors */ + __m128i v0; + __m128i v1; + __m128i v2; + __m128i v3; + __m128i q0; + __m128i q1; + __m128i q2; + __m128i q3; + __m128i x0; + __m128i x1; + __m128i x2; + __m128i x3; + __m128i cq = _mm_set1_epi8('"'); + __m128i cx = _mm_set1_epi8('\\'); + + /* partial masks */ + uint32_t s0; + uint32_t s1; + uint32_t s2; + uint32_t s3; + uint32_t t0; + uint32_t t1; + uint32_t t2; + uint32_t t3; +#endif + +#define m0_mask(add) \ + m1 &= ~cr; \ + fe = (m1 << 1) | cr; \ + os = (m1 & ~fe) & ODD_MASK; \ + es = add(os, m1, &cr) << 1; \ + m0 &= ~(fe & (es ^ EVEN_MASK)); + + /* 64-byte SIMD loop */ + while (likely(nb >= 64)) { +#if USE_AVX2 + v0 = _mm256_loadu_si256 ((const void *)(sp + 0)); + v1 = _mm256_loadu_si256 ((const void *)(sp + 32)); + q0 = _mm256_cmpeq_epi8 (v0, cq); + q1 = _mm256_cmpeq_epi8 (v1, cq); + x0 = _mm256_cmpeq_epi8 (v0, cx); + x1 = _mm256_cmpeq_epi8 (v1, cx); + s0 = _mm256_movemask_epi8 (q0); + s1 = _mm256_movemask_epi8 (q1); + t0 = _mm256_movemask_epi8 (x0); + t1 = _mm256_movemask_epi8 (x1); + m0 = ((uint64_t)s1 << 32) | (uint64_t)s0; + m1 = ((uint64_t)t1 << 32) | (uint64_t)t0; +#else + v0 = _mm_loadu_si128 ((const void *)(sp + 0)); + v1 = _mm_loadu_si128 ((const void *)(sp + 16)); + v2 = _mm_loadu_si128 ((const void *)(sp + 32)); + v3 = _mm_loadu_si128 ((const void *)(sp + 48)); + q0 = _mm_cmpeq_epi8 (v0, cq); + q1 = _mm_cmpeq_epi8 (v1, cq); + q2 = _mm_cmpeq_epi8 (v2, cq); + q3 = _mm_cmpeq_epi8 (v3, cq); + x0 = _mm_cmpeq_epi8 (v0, cx); + x1 = _mm_cmpeq_epi8 (v1, cx); + x2 = _mm_cmpeq_epi8 (v2, cx); + x3 = _mm_cmpeq_epi8 (v3, cx); + s0 = _mm_movemask_epi8 (q0); + s1 = _mm_movemask_epi8 (q1); + s2 = _mm_movemask_epi8 (q2); + s3 = _mm_movemask_epi8 (q3); + t0 = _mm_movemask_epi8 (x0); + t1 = _mm_movemask_epi8 (x1); + t2 = _mm_movemask_epi8 (x2); + t3 = _mm_movemask_epi8 (x3); + m0 = ((uint64_t)s3 << 48) | ((uint64_t)s2 << 32) | ((uint64_t)s1 << 16) | (uint64_t)s0; + m1 = ((uint64_t)t3 << 48) | ((uint64_t)t2 << 32) | ((uint64_t)t1 << 16) | (uint64_t)t0; +#endif + /** update first quote position */ + if (unlikely(m1 != 0)) { + ep_setx(sp - ss + __builtin_ctzll(m1)) + } + + /** mask all the escaped quotes */ + if (unlikely(m1 != 0 || cr != 0)) { + m0_mask(add64) + } + + /* check for end quote */ + if (m0 != 0) { + return sp - ss + __builtin_ctzll(m0) + 1; + } + + /* move to the next block */ + sp += 64; + nb -= 64; + } + + /* 32-byte SIMD round */ + if (likely(nb >= 32)) { +#if USE_AVX2 + v0 = _mm256_loadu_si256 ((const void *)sp); + q0 = _mm256_cmpeq_epi8 (v0, cq); + x0 = _mm256_cmpeq_epi8 (v0, cx); + s0 = _mm256_movemask_epi8 (q0); + t0 = _mm256_movemask_epi8 (x0); + m0 = (uint64_t)s0; + m1 = (uint64_t)t0; +#else + v0 = _mm_loadu_si128 ((const void *)(sp + 0)); + v1 = _mm_loadu_si128 ((const void *)(sp + 16)); + q0 = _mm_cmpeq_epi8 (v0, cq); + q1 = _mm_cmpeq_epi8 (v1, cq); + x0 = _mm_cmpeq_epi8 (v0, cx); + x1 = _mm_cmpeq_epi8 (v1, cx); + s0 = _mm_movemask_epi8 (q0); + s1 = _mm_movemask_epi8 (q1); + t0 = _mm_movemask_epi8 (x0); + t1 = _mm_movemask_epi8 (x1); + m0 = ((uint64_t)s1 << 16) | (uint64_t)s0; + m1 = ((uint64_t)t1 << 16) | (uint64_t)t0; +#endif + + /** update first quote position */ + if (unlikely(m1 != 0)) { + ep_setx(sp - ss + __builtin_ctzll(m1)) + } + + /** mask all the escaped quotes */ + if (unlikely(m1 != 0 || cr != 0)) { + m0_mask(add32) + } + + /* check for end quote */ + if (m0 != 0) { + return sp - ss + __builtin_ctzll(m0) + 1; + } + + /* move to the next block */ + sp += 32; + nb -= 32; + } + + /* check for carry */ + if (unlikely(cr != 0)) { + if (nb == 0) { + return -ERR_EOF; + } else { + ep_setc() + sp++, nb--; + } + } + + /* handle the remaining bytes with scalar code */ + while (nb-- > 0 && (ch = *sp++) != '"') { + if (unlikely(ch == '\\')) { + if (nb == 0) { + return -ERR_EOF; + } else { + ep_setc() + sp++, nb--; + } + } + } + +#undef ep_init +#undef ep_setc +#undef ep_setx +#undef m0_mask + + /* check for quotes */ + if (ch == '"') { + return sp - ss; + } else { + return -ERR_EOF; + } +} + +#if USE_AVX2 + +static always_inline int _mm256_get_mask(__m256i v, __m256i t) { + return _mm256_movemask_epi8(_mm256_cmpeq_epi8(v, t)); +} + +// contrl char: 0x00 ~ 0x1F +static always_inline int _mm256_cchars_mask(__m256i v) { + __m256i e1 = _mm256_cmpgt_epi8 (v, _mm256_set1_epi8(-1)); + __m256i e2 = _mm256_cmpgt_epi8 (v, _mm256_set1_epi8(31)); + return _mm256_movemask_epi8 (_mm256_andnot_si256 (e2, e1)); +} + +// ascii: 0x00 ~ 0x7F +static always_inline int _mm256_nonascii_mask(__m256i v) { + return _mm256_movemask_epi8(v); +} + +#endif + +static always_inline int _mm_get_mask(__m128i v, __m128i t) { + return _mm_movemask_epi8(_mm_cmpeq_epi8(v, t)); +} + +// contrl char: 0x00 ~ 0x1F +static always_inline int _mm_cchars_mask(__m128i v) { + __m128i e1 = _mm_cmpgt_epi8 (v, _mm_set1_epi8(-1)); + __m128i e2 = _mm_cmpgt_epi8 (v, _mm_set1_epi8(31)); + return _mm_movemask_epi8 (_mm_andnot_si128 (e2, e1)); +} + +// ascii: 0x00 ~ 0x7F +static always_inline int _mm_nonascii_mask(__m128i v) { + return _mm_movemask_epi8(v); +} + +static always_inline ssize_t advance_string_validate(const GoString *src, long p, int64_t *ep) { + char ch; + uint64_t m0, m1, m2; + uint64_t es, fe, os; + uint64_t cr = 0; + long qp = 0; + long np = 0; + + /* buffer pointers */ + size_t nb = src->len; + const char * sp = src->buf; + const char * ss = src->buf; + + /* prevent out-of-bounds accessing */ + if (unlikely(nb == p)) { + return -ERR_EOF; + } + +#define ep_init() *ep = -1; +#define ep_setc() ep_setx(sp - ss - 1) +#define ep_setx(x) if (*ep == -1) { *ep = (x); } +#define ep_seterr(x) *ep = (x); + + /* seek to `p` */ + nb -= p; + sp += p; + ep_init() + +#if USE_AVX2 + /* initialize vectors */ + __m256i v0; + __m256i v1; + __m256i cq = _mm256_set1_epi8('"'); + __m256i cx = _mm256_set1_epi8('\\'); + + /* partial masks */ + uint32_t s0, s1; + uint32_t t0, t1; + uint32_t c0, c1; +#else + /* initialize vectors */ + __m128i v0; + __m128i v1; + __m128i v2; + __m128i v3; + __m128i cq = _mm_set1_epi8('"'); + __m128i cx = _mm_set1_epi8('\\'); + + /* partial masks */ + uint32_t s0, s1, s2, s3; + uint32_t t0, t1, t2, t3; + uint32_t c0, c1, c2, c3; +#endif + +#define m0_mask(add) \ + m1 &= ~cr; \ + fe = (m1 << 1) | cr; \ + os = (m1 & ~fe) & ODD_MASK; \ + es = add(os, m1, &cr) << 1; \ + m0 &= ~(fe & (es ^ EVEN_MASK)); + + /* 64-byte SIMD loop */ + while (likely(nb >= 64)) { +#if USE_AVX2 + v0 = _mm256_loadu_si256 ((const void *)(sp + 0)); + v1 = _mm256_loadu_si256 ((const void *)(sp + 32)); + s0 = _mm256_get_mask(v0, cq); + s1 = _mm256_get_mask(v1, cq); + t0 = _mm256_get_mask(v0, cx); + t1 = _mm256_get_mask(v1, cx); + c0 = _mm256_cchars_mask(v0); + c1 = _mm256_cchars_mask(v1); + m0 = ((uint64_t)s1 << 32) | (uint64_t)s0; + m1 = ((uint64_t)t1 << 32) | (uint64_t)t0; + m2 = ((uint64_t)c1 << 32) | (uint64_t)c0; +#else + v0 = _mm_loadu_si128 ((const void *)(sp + 0)); + v1 = _mm_loadu_si128 ((const void *)(sp + 16)); + v2 = _mm_loadu_si128 ((const void *)(sp + 32)); + v3 = _mm_loadu_si128 ((const void *)(sp + 48)); + s0 = _mm_get_mask(v0, cq); + s1 = _mm_get_mask(v1, cq); + s2 = _mm_get_mask(v2, cq); + s3 = _mm_get_mask(v3, cq); + t0 = _mm_get_mask(v0, cx); + t1 = _mm_get_mask(v1, cx); + t2 = _mm_get_mask(v2, cx); + t3 = _mm_get_mask(v3, cx); + c0 = _mm_cchars_mask(v0); + c1 = _mm_cchars_mask(v1); + c2 = _mm_cchars_mask(v2); + c3 = _mm_cchars_mask(v3); + m0 = ((uint64_t)s3 << 48) | ((uint64_t)s2 << 32) | ((uint64_t)s1 << 16) | (uint64_t)s0; + m1 = ((uint64_t)t3 << 48) | ((uint64_t)t2 << 32) | ((uint64_t)t1 << 16) | (uint64_t)t0; + m2 = ((uint64_t)c3 << 48) | ((uint64_t)c2 << 32) | ((uint64_t)c1 << 16) | (uint64_t)c0; + +#endif + + /** update first quote position */ + if (unlikely(m1 != 0)) { + ep_setx(sp - ss + __builtin_ctzll(m1)) + } + + /** mask all the escaped quotes */ + if (unlikely(m1 != 0 || cr != 0)) { + m0_mask(add64) + } + + qp = m0 ? __builtin_ctzll(m0) : 64; + np = m2 ? __builtin_ctzll(m2) : 64; + + /* get the position of end quote */ + if (m0 != 0) { + /* check control chars in JSON string */ + if (unlikely(np < qp)) { + ep_seterr(sp - ss + np) + + return -ERR_INVAL; + } + return sp - ss + qp + 1; + } + + /* check control chars in JSON string */ + if (unlikely(m2 != 0)) { + ep_setx(sp - ss + np) + + return -ERR_INVAL; + } + + /* move to the next block */ + sp += 64; + nb -= 64; + } + + /* 32-byte SIMD round */ + if (likely(nb >= 32)) { +#if USE_AVX2 + v0 = _mm256_loadu_si256 ((const void *)sp); + s0 = _mm256_get_mask (v0, cq); + t0 = _mm256_get_mask (v0, cx); + c0 = _mm256_cchars_mask(v0); + m0 = (uint64_t)s0; + m1 = (uint64_t)t0; + m2 = (uint64_t)c0; +#else + v0 = _mm_loadu_si128 ((const void *)(sp + 0)); + v1 = _mm_loadu_si128 ((const void *)(sp + 16)); + s0 = _mm_get_mask(v0, cq); + s1 = _mm_get_mask(v1, cq); + t0 = _mm_get_mask(v0, cx); + t1 = _mm_get_mask(v1, cx); + c0 = _mm_cchars_mask(v0); + c1 = _mm_cchars_mask(v1); + m0 = ((uint64_t)s1 << 16) | (uint64_t)s0; + m1 = ((uint64_t)t1 << 16) | (uint64_t)t0; + m2 = ((uint64_t)c1 << 16) | (uint64_t)c0; +#endif + + /** update first quote position */ + if (unlikely(m1 != 0)) { + ep_setx(sp - ss + __builtin_ctzll(m1)) + } + + /** mask all the escaped quotes */ + if (unlikely(m1 != 0 || cr != 0)) { + m0_mask(add32) + } + + qp = m0 ? __builtin_ctzll(m0) : 64; + np = m2 ? __builtin_ctzll(m2) : 64; + + /* get the position of end quote */ + if (m0 != 0) { + if (unlikely(np < qp)) { + ep_seterr(sp - ss + np) + return -ERR_INVAL; + } + return sp - ss + qp + 1; + } + + /* check control chars in JSON string */ + if (unlikely(m2 != 0)) { + ep_seterr(sp - ss + __builtin_ctzll(m2)) + return -ERR_INVAL; + } + + /* move to the next block */ + sp += 32; + nb -= 32; + } + + /* check for carry */ + if (unlikely(cr != 0)) { + if (nb == 0) { + return -ERR_EOF; + } else { + ep_setc() + sp++, nb--; + } + } + + /* handle the remaining bytes with scalar code */ + while (nb > 0) { + ch = *sp; + if (ch == '"') { + + return sp - ss + 1; + } + + /* valid the escaped chars */ + if (unlikely(ch == '\\')) { + if (nb == 1) { + return -ERR_EOF; + } + ep_setx(sp - ss) + sp += 2, nb -= 2; + continue; + } + + /* valid unescaped chars */ + if (unlikely( ch >= 0 && ch <= 0x1f)) { // control chars + ep_seterr(sp - ss) + return -ERR_INVAL; + } + + sp++, nb--; + } + return -ERR_EOF; +#undef ep_init +#undef ep_setc +#undef ep_setx +#undef ep_seterr +#undef m0_mask +} + +static always_inline ssize_t advance_string(const GoString *src, long p, int64_t *ep, uint64_t flags) { + if ((flags & MASK_VALIDATE_STRING) != 0) { + return advance_string_validate(src, p, ep); + } else { + return advance_string_default(src, p, ep); + } +} + +#define set_vt(t) \ + ret->vt = t; + +#define init_ret(t) \ + ret->vt = t; \ + ret->dv = 0.0; \ + ret->iv = 0; \ + ret->ep = *p; + +#define check_eof() \ + if (i >= n) { \ + *p = n; \ + ret->vt = -ERR_EOF; \ + return; \ + } + +#define check_sign(on_neg) \ + if (s[i] == '-') { \ + i++; \ + on_neg; \ + check_eof() \ + } + +#define check_digit() \ + if (s[i] < '0' || s[i] > '9') { \ + *p = i; \ + ret->vt = -ERR_INVAL; \ + return; \ + } + +#define check_leading_zero() \ + if (s[i] == '0' && (i >= n || (s[i + 1] != '.' && s[i + 1] != 'e' && s[i + 1] != 'E'))) { \ + *p = ++i; \ + return; \ + } + +#define parse_sign(sgn) \ + if (s[i] == '+' || s[i] == '-') { \ + sgn = s[i++] == '+' ? 1 : -1; \ + check_eof() \ + } + +#define is_digit(val) \ + '0' <= val && val <= '9' + +#define add_integer_to_mantissa(man, man_nd, exp10, dig) \ + if (man_nd < 19) { \ + man = man * 10 + dig; \ + man_nd++; \ + } else { \ + exp10++; \ + } + +#define add_float_to_mantissa(man, man_nd, exp10, dig) \ + man = man * 10 + dig; \ + man_nd++; \ + exp10--; + +#define parse_float_digits(val, sgn, ...) \ + while (i < n && s[i] >= '0' && s[i] <= '9' __VA_ARGS__) { \ + val *= 10; \ + val += sgn * (s[i++] - '0'); \ + } + +#define parse_integer_digits(val, sgn, ovf) \ + while (i < n && s[i] >= '0' && s[i] <= '9') { \ + if (add_digit_overflow(val, sgn * (s[i++] - '0'))) { \ + ovf = 1; \ + break; \ + } \ + } + +#define add_digit_overflow(val, chr) ( \ + __builtin_mul_overflow(val, 10, &val) || \ + __builtin_add_overflow(val, chr, &val) \ +) + +#define vinteger(type, sgn, on_neg) \ + int ovf = 0; \ + type val = 0; \ + \ + /* initial buffer pointers */ \ + long i = *p; \ + size_t n = src->len; \ + const char * s = src->buf; \ + \ + /* initialize the result, and check for '-' */ \ + init_ret(V_INTEGER) \ + check_eof() \ + check_sign(on_neg) \ + \ + /* check for leading zero or any digits */ \ + check_digit() \ + check_leading_zero() \ + parse_integer_digits(val, sgn, ovf) \ + \ + /* check for overflow */ \ + if (ovf) { \ + *p = i - 1; \ + ret->vt = -ERR_OVERFLOW; \ + return; \ + } \ + \ + /* check for the decimal part */ \ + if (i < n && s[i] == '.') { \ + *p = i; \ + ret->vt = -ERR_NUMBER_FMT; \ + return; \ + } \ + \ + /* check for the exponent part */ \ + if (i < n && (s[i] == 'e' || s[i] == 'E')) { \ + *p = i; \ + ret->vt = -ERR_NUMBER_FMT; \ + return; \ + } \ + \ + /* update the result */ \ + *p = i; \ + ret->iv = val; + +/** check whether float can represent the val exactly **/ +static always_inline bool is_atof_exact(uint64_t man, int exp, int sgn, double *val) { + *val = (double)man; + + if (man >> 52 != 0) { + return false; + } + + /* equal to if (sgn == -1) { *val *= -1; } */ + *(uint64_t *)val |= ((uint64_t)(sgn) >> 63 << 63); + + if (exp == 0 || man == 0) { + return true; + } else if (exp > 0 && exp <= 15+22) { + /* uint64 integers: accurate range <= 10^15 * + * Powers of 10: accurate range <= 10^22, as P10_TAB * + * Example: man 1, exp 36, is ok */ + if (exp > 22) { + *val *= P10_TAB[exp-22]; + exp = 22; + } + + /* f is not accurate when too larger */ + if (*val > 1e15 || *val < -1e15) { + return false; + } + + *val *= P10_TAB[exp]; + return true; + } else if (exp < 0 && exp >= -22) { + *val /= P10_TAB[-exp]; + return true; + } + + return false; +} + +static always_inline double atof_fast(uint64_t man, int exp, int sgn, int trunc, double *val) { + double val_up = 0.0; + + /* look-up for fast atof if the conversion can be exactly */ + if (is_atof_exact(man, exp, sgn, val)) { + return true; + } + + /* A fast atof algorithm for high percison */ + if (atof_eisel_lemire64_1(man, exp, sgn, val)) { + if (!trunc || (atof_eisel_lemire64_1(man+1, exp, sgn, &val_up) && val_up == *val)) { + return true; + } + } + + return false; +} + +static bool always_inline is_overflow(uint64_t man, int sgn, int exp10) { + /* the former exp10 != 0 means man has overflowed + * the later euqals to man*sgn < INT64_MIN or > INT64_MAX */ + return exp10 != 0 || + ((man >> 63) == 1 && ((uint64_t)sgn & man) != (1ull << 63)); +} + +static INLINE_FOR_ARM void vnumber_1(const GoString *src, long *p, JsonState *ret) { + int sgn = 1; + uint64_t man = 0; // mantissa for double (float64) + int man_nd = 0; // # digits of mantissa, 10 ^ 19 fits uint64_t + int exp10 = 0; // val = sgn * man * 10 ^ exp10 + int trunc = 0; + double val = 0; + + /* initial buffer pointers */ + long i = *p; + size_t n = src->len; + const char * s = src->buf; + char *dbuf = ret->dbuf; + ssize_t dcap = ret->dcap; + + /* initialize the result, and check for EOF */ + init_ret(V_INTEGER) + check_eof() + check_sign(sgn = -1) + + /* check for leading zero */ + check_digit() + check_leading_zero() + + /* parse the integer part */ + while (i < n && is_digit(s[i])) { + add_integer_to_mantissa(man, man_nd, exp10, (s[i] - '0')) + i++; + } + + if (exp10 > 0) { + trunc = 1; + } + + /* check for decimal points */ + if (i < n && s[i] == '.') { + i++; + set_vt(V_DOUBLE) + check_eof() + check_digit() + } + + /* skip the leading zeros of 0.000xxxx */ + if (man == 0 && exp10 == 0) { + while (i < n && s[i] == '0') { + i++; + exp10--; + } + man = 0; + man_nd = 0; + } + + /* the fractional part (uint64_t mantissa can represent at most 19 digits) */ + while (i < n && man_nd < 19 && is_digit(s[i])) { + add_float_to_mantissa(man, man_nd, exp10, (s[i] - '0')) + i++; + } + + /* skip the remaining digits */ + while (i < n && is_digit(s[i])) { + trunc = 1; + i++; + } + + /* check for exponent */ + if (i < n && (s[i] == 'e' || s[i] == 'E')) { + int esm = 1; + int exp = 0; + + /* check for the '+' or '-' sign, and parse the power */ + i++; + set_vt(V_DOUBLE) + check_eof() + parse_sign(esm) + check_digit() + while (i < n && is_digit(s[i])) { + if (exp < 10000) { + exp = exp * 10 + (s[i] - '0'); + } + i++; + } + exp10 += exp * esm; + goto parse_float; + } + + if (ret->vt == V_INTEGER) { + if (!is_overflow(man, sgn, exp10)) { + ret->iv = (int64_t)man * sgn; + + /* following lines equal to ret->dv = (double)(man) * sgn */ + ret->dv = (double)(man); + *(uint64_t *)&ret->dv |= ((uint64_t)(sgn) >> 63 << 63); + + *p = i; + return; + } + set_vt(V_DOUBLE) + } + +parse_float: + /* when fast algorithms failed, use slow fallback.*/ + if(!atof_fast(man, exp10, sgn, trunc, &val)) { + val = atof_native_1(s + *p, i - *p, dbuf, dcap); + } + + /* check parsed double val */ + if (is_infinity(val)) { + ret->vt = -ERR_FLOAT_INF; + } + + /* update the result */ + ret->dv = val; + *p = i; +} + +/** Value Skipping FSM **/ + +#define FSM_VAL 0 +#define FSM_ARR 1 +#define FSM_OBJ 2 +#define FSM_KEY 3 +#define FSM_ELEM 4 +#define FSM_ARR_0 5 +#define FSM_OBJ_0 6 + +#define FSM_DROP(v) (v)->sp-- +#define FSM_REPL(v, t) (v)->vt[(v)->sp - 1] = (t) + +#define FSM_CHAR(c) do { if (ch != (c)) return -ERR_INVAL; } while (0) +#define FSM_XERR(v) do { long r = (v); if (r < 0) return r; } while (0) + +static always_inline void fsm_init(StateMachine *self, int vt) { + self->sp = 1; + self->vt[0] = vt; +} + +static always_inline long fsm_push(StateMachine *self, int vt) { + if (self->sp >= MAX_RECURSE) { + return -ERR_RECURSE_MAX; + } else { + self->vt[self->sp++] = vt; + return 0; + } +} + +static INLINE_FOR_ARM long fsm_exec_1(StateMachine *self, const GoString *src, long *p, uint64_t flags) { + int vt; + char ch; + long vi = -1; + + /* run until no more nested values */ + while (self->sp) { + ch = advance_ns(src, p); + if (ch == 0) { + return -ERR_EOF; + } + vt = self->vt[self->sp - 1]; + + /* set the start address if any */ + if (vi == -1) { + vi = *p - 1; + } + + /* check for special types */ + switch (vt) { + default: { + FSM_DROP(self); + break; + } + + /* arrays */ + case FSM_ARR: { + switch (ch) { + case ']' : FSM_DROP(self); continue; + case ',' : FSM_XERR(fsm_push(self, FSM_VAL)); continue; + default : return -ERR_INVAL; + } + } + + /* objects */ + case FSM_OBJ: { + switch (ch) { + case '}' : FSM_DROP(self); continue; + case ',' : FSM_XERR(fsm_push(self, FSM_KEY)); continue; + default : return -ERR_INVAL; + } + } + + /* object keys */ + case FSM_KEY: { + FSM_CHAR('"'); + FSM_REPL(self, FSM_ELEM); + FSM_XERR(skip_string_1(src, p, flags)); + continue; + } + + /* object element */ + case FSM_ELEM: { + FSM_CHAR(':'); + FSM_REPL(self, FSM_VAL); + continue; + } + + /* arrays, first element */ + case FSM_ARR_0: { + if (ch == ']') { + FSM_DROP(self); + continue; + } else { + FSM_REPL(self, FSM_ARR); + break; + } + } + + /* objects, first pair */ + case FSM_OBJ_0: { + switch (ch) { + default: { + return -ERR_INVAL; + } + + /* empty object */ + case '}': { + FSM_DROP(self); + continue; + } + + /* the quote of the first key */ + case '"': { + FSM_REPL(self, FSM_OBJ); + FSM_XERR(skip_string_1(src, p, flags)); + FSM_XERR(fsm_push(self, FSM_ELEM)); + continue; + } + } + } + } + + /* simple values */ + switch (ch) { + case '0' : /* fallthrough */ + case '1' : /* fallthrough */ + case '2' : /* fallthrough */ + case '3' : /* fallthrough */ + case '4' : /* fallthrough */ + case '5' : /* fallthrough */ + case '6' : /* fallthrough */ + case '7' : /* fallthrough */ + case '8' : /* fallthrough */ + case '9' : FSM_XERR(skip_positive_1(src, p)); break; + case '-' : FSM_XERR(skip_negative_1(src, p)); break; + case 'n' : FSM_XERR(advance_dword(src, p, 1, *p - 1, VS_NULL)); break; + case 't' : FSM_XERR(advance_dword(src, p, 1, *p - 1, VS_TRUE)); break; + case 'f' : FSM_XERR(advance_dword(src, p, 0, *p - 1, VS_ALSE)); break; + case '[' : FSM_XERR(fsm_push(self, FSM_ARR_0)); break; + case '{' : FSM_XERR(fsm_push(self, FSM_OBJ_0)); break; + case '"' : FSM_XERR(skip_string_1(src, p, flags)); break; + case 0 : return -ERR_EOF; + default : return -ERR_INVAL; + } + } + + /* all done */ + return vi; +} + +#undef FSM_DROP +#undef FSM_REPL +#undef FSM_CHAR +#undef FSM_XERR + +#define check_bits(mv) \ + if (unlikely((v = mv & (mv - 1)) != 0)) { \ + return -(sp - ss + __builtin_ctz(v) + 1); \ + } + +#define check_sidx(iv) \ + if (likely(iv == -1)) { \ + iv = sp - ss - 1; \ + } else { \ + return -(sp - ss); \ + } + +#define check_vidx(iv, mv) \ + if (mv != 0) { \ + if (likely(iv == -1)) { \ + iv = sp - ss + __builtin_ctz(mv); \ + } else { \ + return -(sp - ss + __builtin_ctz(mv) + 1); \ + } \ + } + +static always_inline long do_skip_number(const char *sp, size_t nb) { + long di = -1; + long ei = -1; + long si = -1; + const char * ss = sp; + + /* check for EOF */ + if (nb == 0) { + return -1; + } + + /* special case of '0' */ + if (*sp == '0' && (nb == 1 || (sp[1] != '.' && sp[1] != 'e' && sp[1] != 'E'))) { + return 1; + } + +#if USE_AVX2 + /* can do with AVX-2 */ + if (likely(nb >= 32)) { + __m256i d9 = _mm256_set1_epi8('9'); + __m256i ds = _mm256_set1_epi8('/'); + __m256i dp = _mm256_set1_epi8('.'); + __m256i el = _mm256_set1_epi8('e'); + __m256i eu = _mm256_set1_epi8('E'); + __m256i xp = _mm256_set1_epi8('+'); + __m256i xm = _mm256_set1_epi8('-'); + + /* 32-byte loop */ + do { + __m256i sb = _mm256_loadu_si256 ((const void *)sp); + __m256i i0 = _mm256_cmpgt_epi8 (sb, ds); + __m256i i9 = _mm256_cmpgt_epi8 (sb, d9); + __m256i id = _mm256_cmpeq_epi8 (sb, dp); + __m256i il = _mm256_cmpeq_epi8 (sb, el); + __m256i iu = _mm256_cmpeq_epi8 (sb, eu); + __m256i ip = _mm256_cmpeq_epi8 (sb, xp); + __m256i im = _mm256_cmpeq_epi8 (sb, xm); + __m256i iv = _mm256_andnot_si256 (i9, i0); + __m256i ie = _mm256_or_si256 (il, iu); + __m256i is = _mm256_or_si256 (ip, im); + __m256i rt = _mm256_or_si256 (iv, id); + __m256i ru = _mm256_or_si256 (ie, is); + __m256i rv = _mm256_or_si256 (rt, ru); + + /* exponent and sign position */ + uint32_t md = _mm256_movemask_epi8(id); + uint32_t me = _mm256_movemask_epi8(ie); + uint32_t ms = _mm256_movemask_epi8(is); + uint32_t mr = _mm256_movemask_epi8(rv); + + /* mismatch position */ + uint32_t v; + uint32_t i = __builtin_ctzll(~(uint64_t)mr | 0x0100000000); + + /* mask out excess characters */ + if (i != 32) { + md &= (1 << i) - 1; + me &= (1 << i) - 1; + ms &= (1 << i) - 1; + } + + /* check & update decimal point, exponent and sign index */ + check_bits(md) + check_bits(me) + check_bits(ms) + check_vidx(di, md) + check_vidx(ei, me) + check_vidx(si, ms) + + /* check for valid number */ + if (i != 32) { + sp += i; + _mm256_zeroupper(); + goto check_index; + } + + /* move to next block */ + sp += 32; + nb -= 32; + } while (nb >= 32); + + /* clear the upper half to prevent AVX-SSE transition penalty */ + _mm256_zeroupper(); + } +#endif + + /* can do with SSE */ + if (likely(nb >= 16)) { + __m128i dc = _mm_set1_epi8(':'); + __m128i ds = _mm_set1_epi8('/'); + __m128i dp = _mm_set1_epi8('.'); + __m128i el = _mm_set1_epi8('e'); + __m128i eu = _mm_set1_epi8('E'); + __m128i xp = _mm_set1_epi8('+'); + __m128i xm = _mm_set1_epi8('-'); + + /* 16-byte loop */ + do { + __m128i sb = _mm_loadu_si128 ((const void *)sp); + __m128i i0 = _mm_cmpgt_epi8 (sb, ds); + __m128i i9 = _mm_cmplt_epi8 (sb, dc); + __m128i id = _mm_cmpeq_epi8 (sb, dp); + __m128i il = _mm_cmpeq_epi8 (sb, el); + __m128i iu = _mm_cmpeq_epi8 (sb, eu); + __m128i ip = _mm_cmpeq_epi8 (sb, xp); + __m128i im = _mm_cmpeq_epi8 (sb, xm); + __m128i iv = _mm_and_si128 (i9, i0); + __m128i ie = _mm_or_si128 (il, iu); + __m128i is = _mm_or_si128 (ip, im); + __m128i rt = _mm_or_si128 (iv, id); + __m128i ru = _mm_or_si128 (ie, is); + __m128i rv = _mm_or_si128 (rt, ru); + + /* exponent and sign position */ + uint32_t md = _mm_movemask_epi8(id); + uint32_t me = _mm_movemask_epi8(ie); + uint32_t ms = _mm_movemask_epi8(is); + uint32_t mr = _mm_movemask_epi8(rv); + + /* mismatch position */ + uint32_t v; + uint32_t i = __builtin_ctzll(~mr | 0x00010000); + + /* mask out excess characters */ + if (i != 16) { + md &= (1 << i) - 1; + me &= (1 << i) - 1; + ms &= (1 << i) - 1; + } + + /* check & update exponent and sign index */ + check_bits(md) + check_bits(me) + check_bits(ms) + check_vidx(di, md) + check_vidx(ei, me) + check_vidx(si, ms) + + /* check for valid number */ + if (i != 16) { + sp += i; + goto check_index; + } + + /* move to next block */ + sp += 16; + nb -= 16; + } while (nb >= 16); + } + + /* remaining bytes, do with scalar code */ + while (likely(nb-- > 0)) { + switch (*sp++) { + case '0' : /* fallthrough */ + case '1' : /* fallthrough */ + case '2' : /* fallthrough */ + case '3' : /* fallthrough */ + case '4' : /* fallthrough */ + case '5' : /* fallthrough */ + case '6' : /* fallthrough */ + case '7' : /* fallthrough */ + case '8' : /* fallthrough */ + case '9' : break; + case '.' : check_sidx(di); break; + case 'e' : /* fallthrough */ + case 'E' : check_sidx(ei); break; + case '+' : /* fallthrough */ + case '-' : check_sidx(si); break; + default : sp--; goto check_index; + } + } +check_index: + if (di == 0 || si == 0 || ei == 0) { + return -1; + } else if (di == sp - ss - 1|| si == sp - ss - 1 || ei == sp - ss - 1) { + return -(sp - ss); + } else if (si > 0 && ei != si - 1) { + return -si - 1; + } else if (di >= 0 && ei >= 0 && di > ei - 1) { + return -di - 1; + } else if (di >= 0 && ei >= 0 && di == ei - 1) { + return -ei - 1; + } else { + return sp - ss; + } +} + +#undef check_bits +#undef check_sidx +#undef check_vidx + +static INLINE_FOR_ARM long skip_string_1(const GoString *src, long *p, uint64_t flags) { + int64_t v = -1; + ssize_t q = *p - 1; // start position + ssize_t e = advance_string(src, *p, &v, flags); + + /* check for errors */ + if (e < 0) { + *p = e == -ERR_EOF ? src->len : v; + return e; + } + + /* update the position */ + *p = e; + return q; +} + +static INLINE_FOR_ARM long skip_negative_1(const GoString *src, long *p) { + long i = *p; + long r = do_skip_number(src->buf + i, src->len - i); + + /* check for errors */ + if (r < 0) { + *p -= r + 1; + return -ERR_INVAL; + } + + /* update value pointer */ + *p += r; + return i - 1; +} + +static INLINE_FOR_ARM long skip_positive_1(const GoString *src, long *p) { + long i = *p - 1; + long r = do_skip_number(src->buf + i, src->len - i); + + /* check for errors */ + if (r < 0) { + *p -= r + 2; + return -ERR_INVAL; + } + + /* update value pointer */ + *p += r - 1; + return i; +} + +static INLINE_FOR_ARM long skip_number_1(const GoString *src, long *p) { + const char* ss = src->buf; + const char* sp = src->buf + *p; + size_t nb = src->len - *p; + long i = *p; + long r; + bool neg = *sp == '-'; + + sp += neg; + nb -= neg; + if (unlikely(nb <= 0)) { + *p = sp - ss; + return -ERR_EOF; + } + + if (unlikely(nb > 0 && (*sp > '9' || *sp < '0'))) { + *p = sp - ss; + return -ERR_INVAL; + } + + r = do_skip_number(sp, nb); + if (unlikely(r < 0)) { + *p = sp - (r + 1) - ss; + return -ERR_INVAL; + } + *p = sp + r - ss; + return i; +} + +static INLINE_FOR_ARM long skip_one_1(const GoString *src, long *p, StateMachine *m, uint64_t flags) { + fsm_init(m, FSM_VAL); + return fsm_exec_1(m, src, p, flags); +} + +static always_inline uint64_t get_maskx64(const char *s, char c) { +#if USE_AVX2 + __m256i v0 = _mm256_loadu_si256((__m256i const *)s); + __m256i v1 = _mm256_loadu_si256((__m256i const *)(s + 32)); + uint32_t m0 = _mm256_movemask_epi8(_mm256_cmpeq_epi8(v0, _mm256_set1_epi8(c))); + uint32_t m1 = _mm256_movemask_epi8(_mm256_cmpeq_epi8(v1, _mm256_set1_epi8(c))); + return ((uint64_t)(m1) << 32) | (uint64_t)(m0); +#else + __m128i v0 = _mm_loadu_si128((__m128i const*)s); + __m128i v1 = _mm_loadu_si128((__m128i const*)(s + 16)); + __m128i v2 = _mm_loadu_si128((__m128i const*)(s + 32)); + __m128i v3 = _mm_loadu_si128((__m128i const*)(s + 48)); + uint32_t m0 = _mm_movemask_epi8(_mm_cmpeq_epi8(v0, _mm_set1_epi8(c))); + uint32_t m1 = _mm_movemask_epi8(_mm_cmpeq_epi8(v1, _mm_set1_epi8(c))); + uint32_t m2 = _mm_movemask_epi8(_mm_cmpeq_epi8(v2, _mm_set1_epi8(c))); + uint32_t m3 = _mm_movemask_epi8(_mm_cmpeq_epi8(v3, _mm_set1_epi8(c))); + return ((uint64_t)(m3) << 48) | ((uint64_t)(m2) << 32) | ((uint64_t)(m1) << 16) | (uint64_t)(m0); +#endif +} + +static always_inline uint64_t get_maskx32(const char *s, char c) { +#if USE_AVX2 + __m256i v0 = _mm256_loadu_si256((__m256i const *)s); + uint64_t m0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v0, _mm256_set1_epi8(c))); + return m0; +#else + __m128i v0 = _mm_loadu_si128((__m128i const*)s); + __m128i v1 = _mm_loadu_si128((__m128i const*)(s + 16)); + uint64_t m0 = (unsigned)_mm_movemask_epi8(_mm_cmpeq_epi8(v0, _mm_set1_epi8(c))); + uint64_t m1 = (unsigned)_mm_movemask_epi8(_mm_cmpeq_epi8(v1, _mm_set1_epi8(c))); + return m0 | (m1 << 16); +#endif +} + +// get the string (besides in quote) mask +static always_inline uint64_t get_string_maskx64(const char *s, uint64_t *prev_inquote, uint64_t *prev_bs) { + uint64_t escaped = *prev_bs; + uint64_t quote_mask = 0, bs_mask = 0; + + /* read and get the quote or backslash bitmask */ + quote_mask = get_maskx64(s, '"'); + bs_mask = get_maskx64(s, '\\'); + + /* get the escaped bitmask */ + if (bs_mask || *prev_bs) { + bs_mask &= ~(*prev_bs); + uint64_t follow_bs = (bs_mask << 1) | *prev_bs; + uint64_t bs_start = bs_mask & ~follow_bs; + uint64_t odd_start = bs_start & ODD_MASK; + uint64_t even_or_oc = add64(odd_start, bs_mask, prev_bs); + uint64_t even_or_escaped = (even_or_oc << 1) ^ EVEN_MASK; + escaped = follow_bs & even_or_escaped; + } else { + *prev_bs = 0; + } + quote_mask &= ~escaped; + + /* get the inquote bitmask */ + uint64_t inquote = _mm_cvtsi128_si64(_mm_clmulepi64_si128(_mm_set_epi64x(0, quote_mask), _mm_set1_epi8('\xFF'), 0)); + inquote ^= *prev_inquote; + *prev_inquote = (uint64_t)(((int64_t)(inquote)) >> 63); + return inquote; +} + +// get the next json structural, '}', ']' or ','。 +#if USE_AVX2 +static always_inline int get_structural_maskx32(const char *s) { + __m256i v = _mm256_loadu_si256((const void *)s); + __m256i e1 = _mm256_cmpeq_epi8(v, _mm256_set1_epi8('}')); + __m256i e2 = _mm256_cmpeq_epi8(v, _mm256_set1_epi8(']')); + __m256i e3 = _mm256_cmpeq_epi8(v, _mm256_set1_epi8(',')); + __m256i sv = _mm256_or_si256(_mm256_or_si256(e1, e2), e3); + return _mm256_movemask_epi8(sv); +} +#endif + +static always_inline int get_structural_maskx16(const char *s) { + __m128i v = _mm_loadu_si128((const void *)s); + __m128i e1 = _mm_cmpeq_epi8(v, _mm_set1_epi8('}')); + __m128i e2 = _mm_cmpeq_epi8(v, _mm_set1_epi8(']')); + __m128i e3 = _mm_cmpeq_epi8(v, _mm_set1_epi8(',')); + __m128i sv = _mm_or_si128(_mm_or_si128(e1, e2), e3); + return _mm_movemask_epi8(sv); +} + +// skip the number at the next '}', ']' or ',' or the ending of json. +static always_inline long skip_number_fast(const GoString *src, long *p) { + size_t nb = src->len - *p; + const char *s = src->buf + *p; + long vi = *p - 1; + int m = 0; + +#if USE_AVX2 + while (likely(nb >= 32)) { + if ((m = get_structural_maskx32(s))) { + *p = s - src->buf + __builtin_ctzll(m); + return vi; + } + s += 32, nb -= 32; + } +#endif + + while (likely(nb >= 16)) { + if ((m = get_structural_maskx16(s))) { + *p = s - src->buf + __builtin_ctzll(m); + return vi; + } + s += 16, nb -= 16; + } + + while (likely(nb > 0)) { + if (*s == '}' || *s == ']' || *s == ',') { + *p = s - src->buf; + return vi; + } + s++, nb--; + } + *p = s - src->buf; + return vi; +} + +static always_inline long skip_container_fast(const GoString *src, long *p, char lc, char rc) { + long nb = src->len - *p; + const char *s = src->buf + *p; + long vi = *p - 1; + + uint64_t prev_inquote = 0, prev_bs = 0; + uint64_t lbrace = 0, rbrace = 0; + size_t lnum = 0, rnum = 0, last_lnum = 0; + uint64_t inquote = 0; + + while (likely(nb >= 64)) { +skip: + inquote = get_string_maskx64(s, &prev_inquote, &prev_bs); + lbrace = get_maskx64(s, lc) & ~inquote; + rbrace = get_maskx64(s, rc) & ~inquote; + + /* traverse each right brace */ + last_lnum = lnum; + while (rbrace > 0) { + uint64_t lbrace_first = (rbrace - 1) & lbrace; + lnum = last_lnum + __builtin_popcountll((int64_t)lbrace_first); + bool is_closed = lnum <= rnum; + if (is_closed) { + *p = src->len - nb + __builtin_ctzll(rbrace) + 1; + // *p is out-of-bound access here + if (*p > src->len) { + *p = src->len; + return -ERR_EOF; + } + return vi; + } + rbrace &= (rbrace - 1); // clear the lowest right brace + rnum ++; + } + lnum = last_lnum + __builtin_popcountll((int64_t)lbrace); + s += 64, nb -= 64; + } + + if (nb <= 0) { + *p = src->len; + return -ERR_EOF; + } + + char tbuf[64] = {0}; + bool cross_page = vec_cross_page(s, 64); + if (cross_page) { + memcpy_p64(tbuf, s, nb); + s = tbuf; + } + goto skip; +} + +static always_inline long skip_object_fast(const GoString *src, long *p) { + return skip_container_fast(src, p, '{', '}'); +} + +static always_inline long skip_array_fast(const GoString *src, long *p) { + return skip_container_fast(src, p, '[', ']'); +} + +static always_inline long skip_string_fast(const GoString *src, long *p) { + const char* s = src->buf + *p; + long nb = src->len - *p; + long vi = *p - 1; + uint64_t prev_bs = 0, escaped; + + while (likely(nb >= 32)) { + uint32_t quote = get_maskx32(s, '"'); + uint32_t bs_mask = get_maskx32(s, '\\'); + if (bs_mask || prev_bs) { + bs_mask &= ~prev_bs; + uint64_t follow_bs = (bs_mask << 1) | prev_bs; + uint64_t bs_start = bs_mask & ~follow_bs; + uint64_t odd_start = bs_start & ODD_MASK; + uint64_t even_or_oc = add32(odd_start, bs_mask, &prev_bs); + uint64_t even_or_escaped = (even_or_oc << 1) ^ EVEN_MASK; + escaped = follow_bs & even_or_escaped; + quote &= ~escaped; + } + if (quote) { + *p = s + __builtin_ctzll(quote) + 1 - src->buf; + return vi; + } + s += 32; + nb -= 32; + } + + if (unlikely(prev_bs != 0)) { + if (nb == 0) return -ERR_EOF; + s++, nb--; + } + + while (likely(nb > 0)) { + if (*s == '\\') { + s += 2, nb -= 2; + continue; + } + if (*s == '"') { + *p = s - src->buf + 1; + return vi; + } + s++, nb--; + } + return -ERR_EOF; +} + +static INLINE_FOR_ARM long skip_one_fast_1(const GoString *src, long *p) { + char c = advance_ns(src, p); + /* set the start address */ + long vi = *p - 1; + switch (c) { + case '[': return skip_array_fast(src, p); + case '{': return skip_object_fast(src, p); + case '"': return skip_string_fast(src, p); + case '-': case '0' ... '9': return skip_number_fast(src, p); + case 't': case 'n': { if (*p + 3 <= src->len) { *p += 3; } else { return -ERR_EOF; } }; break; + case 'f': { if (*p + 4 <= src->len) { *p += 4; } else { return -ERR_EOF; } }; break; + case 0 : return -ERR_EOF; + default : *p -= 1; return -ERR_INVAL; // backward error position + } + return vi; +} + + +static always_inline GoKind kind(const GoIface* iface) { + return (iface->type->kind_flags) & GO_KIND_MASK; +} + +static always_inline bool is_int(const GoIface* iface) { + return iface->type != NULL && kind(iface) == Int; +} + +static always_inline bool is_str(const GoIface* iface) { + return iface->type != NULL && kind(iface) == String; +} + +static always_inline GoString get_str(const GoIface* iface) { + return *(GoString*)(iface->value); +} + +static always_inline int64_t get_int(const GoIface* iface) { + return *(int64_t*)(iface->value); +} + +// xmemcmpeq return true if s1 and s2 is equal for the n bytes, otherwise, return false. +static always_inline bool xmemcmpeq(const char * s1, const char * s2, size_t n) { + bool c1, c2; +#if USE_AVX2 + while (n >= 32) { + __m256i v1 = _mm256_loadu_si256((const void *)s1); + __m256i v2 = _mm256_loadu_si256((const void *)s2); + uint32_t mask = ~((uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v1, v2))); + if (mask) return false; + s1 += 32; + s2 += 32; + n -= 32; + }; + c1 = vec_cross_page(s1, 32); + c2 = vec_cross_page(s2, 32); + // not cross page + if (!c1 && !c2) { + __m256i v1 = _mm256_loadu_si256((const void *)s1); + __m256i v2 = _mm256_loadu_si256((const void *)s2); + uint32_t mask = ~((uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v1, v2))); + bool eq = (mask == 0) || (__builtin_ctzll(mask) >= n); + return eq; + } +#endif + while (n >= 16) { + __m128i v1 = _mm_loadu_si128((const void *)s1); + __m128i v2 = _mm_loadu_si128((const void *)s2); + uint16_t mask = ~((uint16_t)_mm_movemask_epi8(_mm_cmpeq_epi8(v1, v2))); + if (mask != 0) return false; + s1 += 16; + s2 += 16; + n -= 16; + }; + c1 = vec_cross_page(s1, 16); + c2 = vec_cross_page(s2, 16); + // not cross page + if (!c1 && !c2) { + __m128i v1 = _mm_loadu_si128((const void *)s1); + __m128i v2 = _mm_loadu_si128((const void *)s2); + uint16_t mask = ~((uint16_t)_mm_movemask_epi8(_mm_cmpeq_epi8(v1, v2))); + bool eq = (mask == 0) || (__builtin_ctzll(mask) >= n); + return eq; + } + // cross page + while (n > 0 && *s1++ == *s2++) n--; + return n == 0; +} + +// match_key return negative if errors, zero if not matched, one if matched. +static always_inline long match_key(const GoString *src, long *p, const GoString key) { + static const long not_match = 0; + int64_t v = -1; + long si = *p; + long se = advance_string_default(src, *p, &v); + if (unlikely(se < 0)) { + *p = src->len; + return -ERR_EOF; + } + + /* update position */ + *p = se; + + /* compare non-escaped strings */ + if (likely(v == -1 || v > se)) { + long sn = se - si - 1; + + // check empty keys + if (!sn && !key.len) { + return true; + } + + return sn == key.len && xmemcmpeq(src->buf + si, key.buf, key.len); + } + + /* deal with escaped strings */ + char buf[8] = {0}; // escaped buffer + const char* sp = src->buf + si; + const char* end = src->buf + se - 1; + const char* kp = key.buf; + const char* ke = key.buf + key.len; + while (sp < end && kp < ke) { + if (*sp == '\\') { + long en = unescape(&sp, end, buf); + if (en < 0) { + *p = sp - src->buf; + return en; + } + const char* ee = buf + en; + const char* ep = buf; + while (kp < ke && ep < ee && *kp == *ep) kp++, ep++; + if (ep != ee) { + return not_match; + } + } else if (*sp == *kp) { + sp++, kp++; + } else { + return not_match; + } + }; + return sp == end && kp == ke; +} diff --git a/native/arm/skip_array.c b/native/arm/skip_array.c new file mode 100644 index 000000000..95c04f713 --- /dev/null +++ b/native/arm/skip_array.c @@ -0,0 +1,6 @@ +#include "scanning.h" + +long skip_array(const GoString *src, long *p, StateMachine *m, uint64_t flags) { + fsm_init(m, FSM_ARR_0); + return fsm_exec_1(m, src, p, flags); +} diff --git a/native/arm/skip_number.c b/native/arm/skip_number.c new file mode 100644 index 000000000..9ffa406bd --- /dev/null +++ b/native/arm/skip_number.c @@ -0,0 +1,5 @@ +#include "scanning.h" + +long skip_number(const GoString *src, long *p) { + return skip_number_1(src, p); +} \ No newline at end of file diff --git a/native/arm/skip_object.c b/native/arm/skip_object.c new file mode 100644 index 000000000..d2629a397 --- /dev/null +++ b/native/arm/skip_object.c @@ -0,0 +1,6 @@ +#include "scanning.h" + +long skip_object(const GoString *src, long *p, StateMachine *m, uint64_t flags) { + fsm_init(m, FSM_OBJ_0); + return fsm_exec_1(m, src, p, flags); +} diff --git a/native/arm/skip_one.c b/native/arm/skip_one.c new file mode 100644 index 000000000..9fcae224c --- /dev/null +++ b/native/arm/skip_one.c @@ -0,0 +1,5 @@ +#include "scanning.h" + +long skip_one(const GoString *src, long *p, StateMachine *m, uint64_t flags) { + return skip_one_1(src, p, m, flags); +} diff --git a/native/arm/skip_one_fast.c b/native/arm/skip_one_fast.c new file mode 100644 index 000000000..7ce8ff5ca --- /dev/null +++ b/native/arm/skip_one_fast.c @@ -0,0 +1,5 @@ +#include "scanning.h" + +long skip_one_fast(const GoString *src, long *p) { + return skip_one_fast_1(src, p); +} \ No newline at end of file diff --git a/native/arm/tab.h b/native/arm/tab.h new file mode 100644 index 000000000..346ef37ca --- /dev/null +++ b/native/arm/tab.h @@ -0,0 +1,695 @@ +/* + * Copyright 2022 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. + */ +#ifndef TAB_H +#define TAB_H + +#include "test/xassert.h" + +struct uint64x2 { + uint64_t hi; + uint64_t lo; +}; +typedef struct uint64x2 uint64x2; + +static const char Digits[200] = { + '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', + '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', + '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', + '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', + '4', '0', '4', '1', '4', '2', '4', '3', '4', '4', '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', + '5', '0', '5', '1', '5', '2', '5', '3', '5', '4', '5', '5', '5', '6', '5', '7', '5', '8', '5', '9', + '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7', '6', '8', '6', '9', + '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', + '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', + '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9', +}; + +static inline bool is_div_pow2(uint64_t val, int32_t e) { + xassert(e >= 0 && e <= 63); + uint64_t mask = (1ull << e) - 1; + return (val & mask) == 0; +} + +static inline char* utoa2(char* p, uint32_t val) { + p[0] = Digits[val]; + p[1] = Digits[val + 1]; + return p + 2; +} + +static inline void copy_two_digs(char* dst, const char* src) { + *(dst) = *(src); + *(dst + 1) = *(src + 1); +} + +static inline const uint64x2 pow10_ceil_sig(int32_t k) { + // There are unique beta and r such that 10^k = beta 2^r and + // 2^127 <= beta < 2^128, namely r = floor(log_2 10^k) - 127 and + // beta = 2^-r 10^k. + // Let g = ceil(beta), so (g-1) 2^r < 10^k <= g 2^r, with the latter + // value being a pretty good overestimate for 10^k. + + // NB: Since for all the required exponents k, we have g < 2^128, + // all constants can be stored in 128-bit integers. + // Reference from: + // https://github.com/abolz/Drachennest/blob/master/src/schubfach_64.cc#L151 + +#define KMIN -292 +#define KMAX 324 + static const uint64x2 g[KMAX - KMIN + 1] = { + {0xFF77B1FCBEBCDC4F, 0x25E8E89C13BB0F7B}, // -292 + {0x9FAACF3DF73609B1, 0x77B191618C54E9AD}, // -291 + {0xC795830D75038C1D, 0xD59DF5B9EF6A2418}, // -290 + {0xF97AE3D0D2446F25, 0x4B0573286B44AD1E}, // -289 + {0x9BECCE62836AC577, 0x4EE367F9430AEC33}, // -288 + {0xC2E801FB244576D5, 0x229C41F793CDA740}, // -287 + {0xF3A20279ED56D48A, 0x6B43527578C11110}, // -286 + {0x9845418C345644D6, 0x830A13896B78AAAA}, // -285 + {0xBE5691EF416BD60C, 0x23CC986BC656D554}, // -284 + {0xEDEC366B11C6CB8F, 0x2CBFBE86B7EC8AA9}, // -283 + {0x94B3A202EB1C3F39, 0x7BF7D71432F3D6AA}, // -282 + {0xB9E08A83A5E34F07, 0xDAF5CCD93FB0CC54}, // -281 + {0xE858AD248F5C22C9, 0xD1B3400F8F9CFF69}, // -280 + {0x91376C36D99995BE, 0x23100809B9C21FA2}, // -279 + {0xB58547448FFFFB2D, 0xABD40A0C2832A78B}, // -278 + {0xE2E69915B3FFF9F9, 0x16C90C8F323F516D}, // -277 + {0x8DD01FAD907FFC3B, 0xAE3DA7D97F6792E4}, // -276 + {0xB1442798F49FFB4A, 0x99CD11CFDF41779D}, // -275 + {0xDD95317F31C7FA1D, 0x40405643D711D584}, // -274 + {0x8A7D3EEF7F1CFC52, 0x482835EA666B2573}, // -273 + {0xAD1C8EAB5EE43B66, 0xDA3243650005EED0}, // -272 + {0xD863B256369D4A40, 0x90BED43E40076A83}, // -271 + {0x873E4F75E2224E68, 0x5A7744A6E804A292}, // -270 + {0xA90DE3535AAAE202, 0x711515D0A205CB37}, // -269 + {0xD3515C2831559A83, 0x0D5A5B44CA873E04}, // -268 + {0x8412D9991ED58091, 0xE858790AFE9486C3}, // -267 + {0xA5178FFF668AE0B6, 0x626E974DBE39A873}, // -266 + {0xCE5D73FF402D98E3, 0xFB0A3D212DC81290}, // -265 + {0x80FA687F881C7F8E, 0x7CE66634BC9D0B9A}, // -264 + {0xA139029F6A239F72, 0x1C1FFFC1EBC44E81}, // -263 + {0xC987434744AC874E, 0xA327FFB266B56221}, // -262 + {0xFBE9141915D7A922, 0x4BF1FF9F0062BAA9}, // -261 + {0x9D71AC8FADA6C9B5, 0x6F773FC3603DB4AA}, // -260 + {0xC4CE17B399107C22, 0xCB550FB4384D21D4}, // -259 + {0xF6019DA07F549B2B, 0x7E2A53A146606A49}, // -258 + {0x99C102844F94E0FB, 0x2EDA7444CBFC426E}, // -257 + {0xC0314325637A1939, 0xFA911155FEFB5309}, // -256 + {0xF03D93EEBC589F88, 0x793555AB7EBA27CB}, // -255 + {0x96267C7535B763B5, 0x4BC1558B2F3458DF}, // -254 + {0xBBB01B9283253CA2, 0x9EB1AAEDFB016F17}, // -253 + {0xEA9C227723EE8BCB, 0x465E15A979C1CADD}, // -252 + {0x92A1958A7675175F, 0x0BFACD89EC191ECA}, // -251 + {0xB749FAED14125D36, 0xCEF980EC671F667C}, // -250 + {0xE51C79A85916F484, 0x82B7E12780E7401B}, // -249 + {0x8F31CC0937AE58D2, 0xD1B2ECB8B0908811}, // -248 + {0xB2FE3F0B8599EF07, 0x861FA7E6DCB4AA16}, // -247 + {0xDFBDCECE67006AC9, 0x67A791E093E1D49B}, // -246 + {0x8BD6A141006042BD, 0xE0C8BB2C5C6D24E1}, // -245 + {0xAECC49914078536D, 0x58FAE9F773886E19}, // -244 + {0xDA7F5BF590966848, 0xAF39A475506A899F}, // -243 + {0x888F99797A5E012D, 0x6D8406C952429604}, // -242 + {0xAAB37FD7D8F58178, 0xC8E5087BA6D33B84}, // -241 + {0xD5605FCDCF32E1D6, 0xFB1E4A9A90880A65}, // -240 + {0x855C3BE0A17FCD26, 0x5CF2EEA09A550680}, // -239 + {0xA6B34AD8C9DFC06F, 0xF42FAA48C0EA481F}, // -238 + {0xD0601D8EFC57B08B, 0xF13B94DAF124DA27}, // -237 + {0x823C12795DB6CE57, 0x76C53D08D6B70859}, // -236 + {0xA2CB1717B52481ED, 0x54768C4B0C64CA6F}, // -235 + {0xCB7DDCDDA26DA268, 0xA9942F5DCF7DFD0A}, // -234 + {0xFE5D54150B090B02, 0xD3F93B35435D7C4D}, // -233 + {0x9EFA548D26E5A6E1, 0xC47BC5014A1A6DB0}, // -232 + {0xC6B8E9B0709F109A, 0x359AB6419CA1091C}, // -231 + {0xF867241C8CC6D4C0, 0xC30163D203C94B63}, // -230 + {0x9B407691D7FC44F8, 0x79E0DE63425DCF1E}, // -229 + {0xC21094364DFB5636, 0x985915FC12F542E5}, // -228 + {0xF294B943E17A2BC4, 0x3E6F5B7B17B2939E}, // -227 + {0x979CF3CA6CEC5B5A, 0xA705992CEECF9C43}, // -226 + {0xBD8430BD08277231, 0x50C6FF782A838354}, // -225 + {0xECE53CEC4A314EBD, 0xA4F8BF5635246429}, // -224 + {0x940F4613AE5ED136, 0x871B7795E136BE9A}, // -223 + {0xB913179899F68584, 0x28E2557B59846E40}, // -222 + {0xE757DD7EC07426E5, 0x331AEADA2FE589D0}, // -221 + {0x9096EA6F3848984F, 0x3FF0D2C85DEF7622}, // -220 + {0xB4BCA50B065ABE63, 0x0FED077A756B53AA}, // -219 + {0xE1EBCE4DC7F16DFB, 0xD3E8495912C62895}, // -218 + {0x8D3360F09CF6E4BD, 0x64712DD7ABBBD95D}, // -217 + {0xB080392CC4349DEC, 0xBD8D794D96AACFB4}, // -216 + {0xDCA04777F541C567, 0xECF0D7A0FC5583A1}, // -215 + {0x89E42CAAF9491B60, 0xF41686C49DB57245}, // -214 + {0xAC5D37D5B79B6239, 0x311C2875C522CED6}, // -213 + {0xD77485CB25823AC7, 0x7D633293366B828C}, // -212 + {0x86A8D39EF77164BC, 0xAE5DFF9C02033198}, // -211 + {0xA8530886B54DBDEB, 0xD9F57F830283FDFD}, // -210 + {0xD267CAA862A12D66, 0xD072DF63C324FD7C}, // -209 + {0x8380DEA93DA4BC60, 0x4247CB9E59F71E6E}, // -208 + {0xA46116538D0DEB78, 0x52D9BE85F074E609}, // -207 + {0xCD795BE870516656, 0x67902E276C921F8C}, // -206 + {0x806BD9714632DFF6, 0x00BA1CD8A3DB53B7}, // -205 + {0xA086CFCD97BF97F3, 0x80E8A40ECCD228A5}, // -204 + {0xC8A883C0FDAF7DF0, 0x6122CD128006B2CE}, // -203 + {0xFAD2A4B13D1B5D6C, 0x796B805720085F82}, // -202 + {0x9CC3A6EEC6311A63, 0xCBE3303674053BB1}, // -201 + {0xC3F490AA77BD60FC, 0xBEDBFC4411068A9D}, // -200 + {0xF4F1B4D515ACB93B, 0xEE92FB5515482D45}, // -199 + {0x991711052D8BF3C5, 0x751BDD152D4D1C4B}, // -198 + {0xBF5CD54678EEF0B6, 0xD262D45A78A0635E}, // -197 + {0xEF340A98172AACE4, 0x86FB897116C87C35}, // -196 + {0x9580869F0E7AAC0E, 0xD45D35E6AE3D4DA1}, // -195 + {0xBAE0A846D2195712, 0x8974836059CCA10A}, // -194 + {0xE998D258869FACD7, 0x2BD1A438703FC94C}, // -193 + {0x91FF83775423CC06, 0x7B6306A34627DDD0}, // -192 + {0xB67F6455292CBF08, 0x1A3BC84C17B1D543}, // -191 + {0xE41F3D6A7377EECA, 0x20CABA5F1D9E4A94}, // -190 + {0x8E938662882AF53E, 0x547EB47B7282EE9D}, // -189 + {0xB23867FB2A35B28D, 0xE99E619A4F23AA44}, // -188 + {0xDEC681F9F4C31F31, 0x6405FA00E2EC94D5}, // -187 + {0x8B3C113C38F9F37E, 0xDE83BC408DD3DD05}, // -186 + {0xAE0B158B4738705E, 0x9624AB50B148D446}, // -185 + {0xD98DDAEE19068C76, 0x3BADD624DD9B0958}, // -184 + {0x87F8A8D4CFA417C9, 0xE54CA5D70A80E5D7}, // -183 + {0xA9F6D30A038D1DBC, 0x5E9FCF4CCD211F4D}, // -182 + {0xD47487CC8470652B, 0x7647C32000696720}, // -181 + {0x84C8D4DFD2C63F3B, 0x29ECD9F40041E074}, // -180 + {0xA5FB0A17C777CF09, 0xF468107100525891}, // -179 + {0xCF79CC9DB955C2CC, 0x7182148D4066EEB5}, // -178 + {0x81AC1FE293D599BF, 0xC6F14CD848405531}, // -177 + {0xA21727DB38CB002F, 0xB8ADA00E5A506A7D}, // -176 + {0xCA9CF1D206FDC03B, 0xA6D90811F0E4851D}, // -175 + {0xFD442E4688BD304A, 0x908F4A166D1DA664}, // -174 + {0x9E4A9CEC15763E2E, 0x9A598E4E043287FF}, // -173 + {0xC5DD44271AD3CDBA, 0x40EFF1E1853F29FE}, // -172 + {0xF7549530E188C128, 0xD12BEE59E68EF47D}, // -171 + {0x9A94DD3E8CF578B9, 0x82BB74F8301958CF}, // -170 + {0xC13A148E3032D6E7, 0xE36A52363C1FAF02}, // -169 + {0xF18899B1BC3F8CA1, 0xDC44E6C3CB279AC2}, // -168 + {0x96F5600F15A7B7E5, 0x29AB103A5EF8C0BA}, // -167 + {0xBCB2B812DB11A5DE, 0x7415D448F6B6F0E8}, // -166 + {0xEBDF661791D60F56, 0x111B495B3464AD22}, // -165 + {0x936B9FCEBB25C995, 0xCAB10DD900BEEC35}, // -164 + {0xB84687C269EF3BFB, 0x3D5D514F40EEA743}, // -163 + {0xE65829B3046B0AFA, 0x0CB4A5A3112A5113}, // -162 + {0x8FF71A0FE2C2E6DC, 0x47F0E785EABA72AC}, // -161 + {0xB3F4E093DB73A093, 0x59ED216765690F57}, // -160 + {0xE0F218B8D25088B8, 0x306869C13EC3532D}, // -159 + {0x8C974F7383725573, 0x1E414218C73A13FC}, // -158 + {0xAFBD2350644EEACF, 0xE5D1929EF90898FB}, // -157 + {0xDBAC6C247D62A583, 0xDF45F746B74ABF3A}, // -156 + {0x894BC396CE5DA772, 0x6B8BBA8C328EB784}, // -155 + {0xAB9EB47C81F5114F, 0x066EA92F3F326565}, // -154 + {0xD686619BA27255A2, 0xC80A537B0EFEFEBE}, // -153 + {0x8613FD0145877585, 0xBD06742CE95F5F37}, // -152 + {0xA798FC4196E952E7, 0x2C48113823B73705}, // -151 + {0xD17F3B51FCA3A7A0, 0xF75A15862CA504C6}, // -150 + {0x82EF85133DE648C4, 0x9A984D73DBE722FC}, // -149 + {0xA3AB66580D5FDAF5, 0xC13E60D0D2E0EBBB}, // -148 + {0xCC963FEE10B7D1B3, 0x318DF905079926A9}, // -147 + {0xFFBBCFE994E5C61F, 0xFDF17746497F7053}, // -146 + {0x9FD561F1FD0F9BD3, 0xFEB6EA8BEDEFA634}, // -145 + {0xC7CABA6E7C5382C8, 0xFE64A52EE96B8FC1}, // -144 + {0xF9BD690A1B68637B, 0x3DFDCE7AA3C673B1}, // -143 + {0x9C1661A651213E2D, 0x06BEA10CA65C084F}, // -142 + {0xC31BFA0FE5698DB8, 0x486E494FCFF30A63}, // -141 + {0xF3E2F893DEC3F126, 0x5A89DBA3C3EFCCFB}, // -140 + {0x986DDB5C6B3A76B7, 0xF89629465A75E01D}, // -139 + {0xBE89523386091465, 0xF6BBB397F1135824}, // -138 + {0xEE2BA6C0678B597F, 0x746AA07DED582E2D}, // -137 + {0x94DB483840B717EF, 0xA8C2A44EB4571CDD}, // -136 + {0xBA121A4650E4DDEB, 0x92F34D62616CE414}, // -135 + {0xE896A0D7E51E1566, 0x77B020BAF9C81D18}, // -134 + {0x915E2486EF32CD60, 0x0ACE1474DC1D122F}, // -133 + {0xB5B5ADA8AAFF80B8, 0x0D819992132456BB}, // -132 + {0xE3231912D5BF60E6, 0x10E1FFF697ED6C6A}, // -131 + {0x8DF5EFABC5979C8F, 0xCA8D3FFA1EF463C2}, // -130 + {0xB1736B96B6FD83B3, 0xBD308FF8A6B17CB3}, // -129 + {0xDDD0467C64BCE4A0, 0xAC7CB3F6D05DDBDF}, // -128 + {0x8AA22C0DBEF60EE4, 0x6BCDF07A423AA96C}, // -127 + {0xAD4AB7112EB3929D, 0x86C16C98D2C953C7}, // -126 + {0xD89D64D57A607744, 0xE871C7BF077BA8B8}, // -125 + {0x87625F056C7C4A8B, 0x11471CD764AD4973}, // -124 + {0xA93AF6C6C79B5D2D, 0xD598E40D3DD89BD0}, // -123 + {0xD389B47879823479, 0x4AFF1D108D4EC2C4}, // -122 + {0x843610CB4BF160CB, 0xCEDF722A585139BB}, // -121 + {0xA54394FE1EEDB8FE, 0xC2974EB4EE658829}, // -120 + {0xCE947A3DA6A9273E, 0x733D226229FEEA33}, // -119 + {0x811CCC668829B887, 0x0806357D5A3F5260}, // -118 + {0xA163FF802A3426A8, 0xCA07C2DCB0CF26F8}, // -117 + {0xC9BCFF6034C13052, 0xFC89B393DD02F0B6}, // -116 + {0xFC2C3F3841F17C67, 0xBBAC2078D443ACE3}, // -115 + {0x9D9BA7832936EDC0, 0xD54B944B84AA4C0E}, // -114 + {0xC5029163F384A931, 0x0A9E795E65D4DF12}, // -113 + {0xF64335BCF065D37D, 0x4D4617B5FF4A16D6}, // -112 + {0x99EA0196163FA42E, 0x504BCED1BF8E4E46}, // -111 + {0xC06481FB9BCF8D39, 0xE45EC2862F71E1D7}, // -110 + {0xF07DA27A82C37088, 0x5D767327BB4E5A4D}, // -109 + {0x964E858C91BA2655, 0x3A6A07F8D510F870}, // -108 + {0xBBE226EFB628AFEA, 0x890489F70A55368C}, // -107 + {0xEADAB0ABA3B2DBE5, 0x2B45AC74CCEA842F}, // -106 + {0x92C8AE6B464FC96F, 0x3B0B8BC90012929E}, // -105 + {0xB77ADA0617E3BBCB, 0x09CE6EBB40173745}, // -104 + {0xE55990879DDCAABD, 0xCC420A6A101D0516}, // -103 + {0x8F57FA54C2A9EAB6, 0x9FA946824A12232E}, // -102 + {0xB32DF8E9F3546564, 0x47939822DC96ABFA}, // -101 + {0xDFF9772470297EBD, 0x59787E2B93BC56F8}, // -100 + {0x8BFBEA76C619EF36, 0x57EB4EDB3C55B65B}, // -99 + {0xAEFAE51477A06B03, 0xEDE622920B6B23F2}, // -98 + {0xDAB99E59958885C4, 0xE95FAB368E45ECEE}, // -97 + {0x88B402F7FD75539B, 0x11DBCB0218EBB415}, // -96 + {0xAAE103B5FCD2A881, 0xD652BDC29F26A11A}, // -95 + {0xD59944A37C0752A2, 0x4BE76D3346F04960}, // -94 + {0x857FCAE62D8493A5, 0x6F70A4400C562DDC}, // -93 + {0xA6DFBD9FB8E5B88E, 0xCB4CCD500F6BB953}, // -92 + {0xD097AD07A71F26B2, 0x7E2000A41346A7A8}, // -91 + {0x825ECC24C873782F, 0x8ED400668C0C28C9}, // -90 + {0xA2F67F2DFA90563B, 0x728900802F0F32FB}, // -89 + {0xCBB41EF979346BCA, 0x4F2B40A03AD2FFBA}, // -88 + {0xFEA126B7D78186BC, 0xE2F610C84987BFA9}, // -87 + {0x9F24B832E6B0F436, 0x0DD9CA7D2DF4D7CA}, // -86 + {0xC6EDE63FA05D3143, 0x91503D1C79720DBC}, // -85 + {0xF8A95FCF88747D94, 0x75A44C6397CE912B}, // -84 + {0x9B69DBE1B548CE7C, 0xC986AFBE3EE11ABB}, // -83 + {0xC24452DA229B021B, 0xFBE85BADCE996169}, // -82 + {0xF2D56790AB41C2A2, 0xFAE27299423FB9C4}, // -81 + {0x97C560BA6B0919A5, 0xDCCD879FC967D41B}, // -80 + {0xBDB6B8E905CB600F, 0x5400E987BBC1C921}, // -79 + {0xED246723473E3813, 0x290123E9AAB23B69}, // -78 + {0x9436C0760C86E30B, 0xF9A0B6720AAF6522}, // -77 + {0xB94470938FA89BCE, 0xF808E40E8D5B3E6A}, // -76 + {0xE7958CB87392C2C2, 0xB60B1D1230B20E05}, // -75 + {0x90BD77F3483BB9B9, 0xB1C6F22B5E6F48C3}, // -74 + {0xB4ECD5F01A4AA828, 0x1E38AEB6360B1AF4}, // -73 + {0xE2280B6C20DD5232, 0x25C6DA63C38DE1B1}, // -72 + {0x8D590723948A535F, 0x579C487E5A38AD0F}, // -71 + {0xB0AF48EC79ACE837, 0x2D835A9DF0C6D852}, // -70 + {0xDCDB1B2798182244, 0xF8E431456CF88E66}, // -69 + {0x8A08F0F8BF0F156B, 0x1B8E9ECB641B5900}, // -68 + {0xAC8B2D36EED2DAC5, 0xE272467E3D222F40}, // -67 + {0xD7ADF884AA879177, 0x5B0ED81DCC6ABB10}, // -66 + {0x86CCBB52EA94BAEA, 0x98E947129FC2B4EA}, // -65 + {0xA87FEA27A539E9A5, 0x3F2398D747B36225}, // -64 + {0xD29FE4B18E88640E, 0x8EEC7F0D19A03AAE}, // -63 + {0x83A3EEEEF9153E89, 0x1953CF68300424AD}, // -62 + {0xA48CEAAAB75A8E2B, 0x5FA8C3423C052DD8}, // -61 + {0xCDB02555653131B6, 0x3792F412CB06794E}, // -60 + {0x808E17555F3EBF11, 0xE2BBD88BBEE40BD1}, // -59 + {0xA0B19D2AB70E6ED6, 0x5B6ACEAEAE9D0EC5}, // -58 + {0xC8DE047564D20A8B, 0xF245825A5A445276}, // -57 + {0xFB158592BE068D2E, 0xEED6E2F0F0D56713}, // -56 + {0x9CED737BB6C4183D, 0x55464DD69685606C}, // -55 + {0xC428D05AA4751E4C, 0xAA97E14C3C26B887}, // -54 + {0xF53304714D9265DF, 0xD53DD99F4B3066A9}, // -53 + {0x993FE2C6D07B7FAB, 0xE546A8038EFE402A}, // -52 + {0xBF8FDB78849A5F96, 0xDE98520472BDD034}, // -51 + {0xEF73D256A5C0F77C, 0x963E66858F6D4441}, // -50 + {0x95A8637627989AAD, 0xDDE7001379A44AA9}, // -49 + {0xBB127C53B17EC159, 0x5560C018580D5D53}, // -48 + {0xE9D71B689DDE71AF, 0xAAB8F01E6E10B4A7}, // -47 + {0x9226712162AB070D, 0xCAB3961304CA70E9}, // -46 + {0xB6B00D69BB55C8D1, 0x3D607B97C5FD0D23}, // -45 + {0xE45C10C42A2B3B05, 0x8CB89A7DB77C506B}, // -44 + {0x8EB98A7A9A5B04E3, 0x77F3608E92ADB243}, // -43 + {0xB267ED1940F1C61C, 0x55F038B237591ED4}, // -42 + {0xDF01E85F912E37A3, 0x6B6C46DEC52F6689}, // -41 + {0x8B61313BBABCE2C6, 0x2323AC4B3B3DA016}, // -40 + {0xAE397D8AA96C1B77, 0xABEC975E0A0D081B}, // -39 + {0xD9C7DCED53C72255, 0x96E7BD358C904A22}, // -38 + {0x881CEA14545C7575, 0x7E50D64177DA2E55}, // -37 + {0xAA242499697392D2, 0xDDE50BD1D5D0B9EA}, // -36 + {0xD4AD2DBFC3D07787, 0x955E4EC64B44E865}, // -35 + {0x84EC3C97DA624AB4, 0xBD5AF13BEF0B113F}, // -34 + {0xA6274BBDD0FADD61, 0xECB1AD8AEACDD58F}, // -33 + {0xCFB11EAD453994BA, 0x67DE18EDA5814AF3}, // -32 + {0x81CEB32C4B43FCF4, 0x80EACF948770CED8}, // -31 + {0xA2425FF75E14FC31, 0xA1258379A94D028E}, // -30 + {0xCAD2F7F5359A3B3E, 0x096EE45813A04331}, // -29 + {0xFD87B5F28300CA0D, 0x8BCA9D6E188853FD}, // -28 + {0x9E74D1B791E07E48, 0x775EA264CF55347E}, // -27 + {0xC612062576589DDA, 0x95364AFE032A819E}, // -26 + {0xF79687AED3EEC551, 0x3A83DDBD83F52205}, // -25 + {0x9ABE14CD44753B52, 0xC4926A9672793543}, // -24 + {0xC16D9A0095928A27, 0x75B7053C0F178294}, // -23 + {0xF1C90080BAF72CB1, 0x5324C68B12DD6339}, // -22 + {0x971DA05074DA7BEE, 0xD3F6FC16EBCA5E04}, // -21 + {0xBCE5086492111AEA, 0x88F4BB1CA6BCF585}, // -20 + {0xEC1E4A7DB69561A5, 0x2B31E9E3D06C32E6}, // -19 + {0x9392EE8E921D5D07, 0x3AFF322E62439FD0}, // -18 + {0xB877AA3236A4B449, 0x09BEFEB9FAD487C3}, // -17 + {0xE69594BEC44DE15B, 0x4C2EBE687989A9B4}, // -16 + {0x901D7CF73AB0ACD9, 0x0F9D37014BF60A11}, // -15 + {0xB424DC35095CD80F, 0x538484C19EF38C95}, // -14 + {0xE12E13424BB40E13, 0x2865A5F206B06FBA}, // -13 + {0x8CBCCC096F5088CB, 0xF93F87B7442E45D4}, // -12 + {0xAFEBFF0BCB24AAFE, 0xF78F69A51539D749}, // -11 + {0xDBE6FECEBDEDD5BE, 0xB573440E5A884D1C}, // -10 + {0x89705F4136B4A597, 0x31680A88F8953031}, // -9 + {0xABCC77118461CEFC, 0xFDC20D2B36BA7C3E}, // -8 + {0xD6BF94D5E57A42BC, 0x3D32907604691B4D}, // -7 + {0x8637BD05AF6C69B5, 0xA63F9A49C2C1B110}, // -6 + {0xA7C5AC471B478423, 0x0FCF80DC33721D54}, // -5 + {0xD1B71758E219652B, 0xD3C36113404EA4A9}, // -4 + {0x83126E978D4FDF3B, 0x645A1CAC083126EA}, // -3 + {0xA3D70A3D70A3D70A, 0x3D70A3D70A3D70A4}, // -2 + {0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCD}, // -1 + {0x8000000000000000, 0x0000000000000000}, // 0 + {0xA000000000000000, 0x0000000000000000}, // 1 + {0xC800000000000000, 0x0000000000000000}, // 2 + {0xFA00000000000000, 0x0000000000000000}, // 3 + {0x9C40000000000000, 0x0000000000000000}, // 4 + {0xC350000000000000, 0x0000000000000000}, // 5 + {0xF424000000000000, 0x0000000000000000}, // 6 + {0x9896800000000000, 0x0000000000000000}, // 7 + {0xBEBC200000000000, 0x0000000000000000}, // 8 + {0xEE6B280000000000, 0x0000000000000000}, // 9 + {0x9502F90000000000, 0x0000000000000000}, // 10 + {0xBA43B74000000000, 0x0000000000000000}, // 11 + {0xE8D4A51000000000, 0x0000000000000000}, // 12 + {0x9184E72A00000000, 0x0000000000000000}, // 13 + {0xB5E620F480000000, 0x0000000000000000}, // 14 + {0xE35FA931A0000000, 0x0000000000000000}, // 15 + {0x8E1BC9BF04000000, 0x0000000000000000}, // 16 + {0xB1A2BC2EC5000000, 0x0000000000000000}, // 17 + {0xDE0B6B3A76400000, 0x0000000000000000}, // 18 + {0x8AC7230489E80000, 0x0000000000000000}, // 19 + {0xAD78EBC5AC620000, 0x0000000000000000}, // 20 + {0xD8D726B7177A8000, 0x0000000000000000}, // 21 + {0x878678326EAC9000, 0x0000000000000000}, // 22 + {0xA968163F0A57B400, 0x0000000000000000}, // 23 + {0xD3C21BCECCEDA100, 0x0000000000000000}, // 24 + {0x84595161401484A0, 0x0000000000000000}, // 25 + {0xA56FA5B99019A5C8, 0x0000000000000000}, // 26 + {0xCECB8F27F4200F3A, 0x0000000000000000}, // 27 + {0x813F3978F8940984, 0x4000000000000000}, // 28 + {0xA18F07D736B90BE5, 0x5000000000000000}, // 29 + {0xC9F2C9CD04674EDE, 0xA400000000000000}, // 30 + {0xFC6F7C4045812296, 0x4D00000000000000}, // 31 + {0x9DC5ADA82B70B59D, 0xF020000000000000}, // 32 + {0xC5371912364CE305, 0x6C28000000000000}, // 33 + {0xF684DF56C3E01BC6, 0xC732000000000000}, // 34 + {0x9A130B963A6C115C, 0x3C7F400000000000}, // 35 + {0xC097CE7BC90715B3, 0x4B9F100000000000}, // 36 + {0xF0BDC21ABB48DB20, 0x1E86D40000000000}, // 37 + {0x96769950B50D88F4, 0x1314448000000000}, // 38 + {0xBC143FA4E250EB31, 0x17D955A000000000}, // 39 + {0xEB194F8E1AE525FD, 0x5DCFAB0800000000}, // 40 + {0x92EFD1B8D0CF37BE, 0x5AA1CAE500000000}, // 41 + {0xB7ABC627050305AD, 0xF14A3D9E40000000}, // 42 + {0xE596B7B0C643C719, 0x6D9CCD05D0000000}, // 43 + {0x8F7E32CE7BEA5C6F, 0xE4820023A2000000}, // 44 + {0xB35DBF821AE4F38B, 0xDDA2802C8A800000}, // 45 + {0xE0352F62A19E306E, 0xD50B2037AD200000}, // 46 + {0x8C213D9DA502DE45, 0x4526F422CC340000}, // 47 + {0xAF298D050E4395D6, 0x9670B12B7F410000}, // 48 + {0xDAF3F04651D47B4C, 0x3C0CDD765F114000}, // 49 + {0x88D8762BF324CD0F, 0xA5880A69FB6AC800}, // 50 + {0xAB0E93B6EFEE0053, 0x8EEA0D047A457A00}, // 51 + {0xD5D238A4ABE98068, 0x72A4904598D6D880}, // 52 + {0x85A36366EB71F041, 0x47A6DA2B7F864750}, // 53 + {0xA70C3C40A64E6C51, 0x999090B65F67D924}, // 54 + {0xD0CF4B50CFE20765, 0xFFF4B4E3F741CF6D}, // 55 + {0x82818F1281ED449F, 0xBFF8F10E7A8921A5}, // 56 + {0xA321F2D7226895C7, 0xAFF72D52192B6A0E}, // 57 + {0xCBEA6F8CEB02BB39, 0x9BF4F8A69F764491}, // 58 + {0xFEE50B7025C36A08, 0x02F236D04753D5B5}, // 59 + {0x9F4F2726179A2245, 0x01D762422C946591}, // 60 + {0xC722F0EF9D80AAD6, 0x424D3AD2B7B97EF6}, // 61 + {0xF8EBAD2B84E0D58B, 0xD2E0898765A7DEB3}, // 62 + {0x9B934C3B330C8577, 0x63CC55F49F88EB30}, // 63 + {0xC2781F49FFCFA6D5, 0x3CBF6B71C76B25FC}, // 64 + {0xF316271C7FC3908A, 0x8BEF464E3945EF7B}, // 65 + {0x97EDD871CFDA3A56, 0x97758BF0E3CBB5AD}, // 66 + {0xBDE94E8E43D0C8EC, 0x3D52EEED1CBEA318}, // 67 + {0xED63A231D4C4FB27, 0x4CA7AAA863EE4BDE}, // 68 + {0x945E455F24FB1CF8, 0x8FE8CAA93E74EF6B}, // 69 + {0xB975D6B6EE39E436, 0xB3E2FD538E122B45}, // 70 + {0xE7D34C64A9C85D44, 0x60DBBCA87196B617}, // 71 + {0x90E40FBEEA1D3A4A, 0xBC8955E946FE31CE}, // 72 + {0xB51D13AEA4A488DD, 0x6BABAB6398BDBE42}, // 73 + {0xE264589A4DCDAB14, 0xC696963C7EED2DD2}, // 74 + {0x8D7EB76070A08AEC, 0xFC1E1DE5CF543CA3}, // 75 + {0xB0DE65388CC8ADA8, 0x3B25A55F43294BCC}, // 76 + {0xDD15FE86AFFAD912, 0x49EF0EB713F39EBF}, // 77 + {0x8A2DBF142DFCC7AB, 0x6E3569326C784338}, // 78 + {0xACB92ED9397BF996, 0x49C2C37F07965405}, // 79 + {0xD7E77A8F87DAF7FB, 0xDC33745EC97BE907}, // 80 + {0x86F0AC99B4E8DAFD, 0x69A028BB3DED71A4}, // 81 + {0xA8ACD7C0222311BC, 0xC40832EA0D68CE0D}, // 82 + {0xD2D80DB02AABD62B, 0xF50A3FA490C30191}, // 83 + {0x83C7088E1AAB65DB, 0x792667C6DA79E0FB}, // 84 + {0xA4B8CAB1A1563F52, 0x577001B891185939}, // 85 + {0xCDE6FD5E09ABCF26, 0xED4C0226B55E6F87}, // 86 + {0x80B05E5AC60B6178, 0x544F8158315B05B5}, // 87 + {0xA0DC75F1778E39D6, 0x696361AE3DB1C722}, // 88 + {0xC913936DD571C84C, 0x03BC3A19CD1E38EA}, // 89 + {0xFB5878494ACE3A5F, 0x04AB48A04065C724}, // 90 + {0x9D174B2DCEC0E47B, 0x62EB0D64283F9C77}, // 91 + {0xC45D1DF942711D9A, 0x3BA5D0BD324F8395}, // 92 + {0xF5746577930D6500, 0xCA8F44EC7EE3647A}, // 93 + {0x9968BF6ABBE85F20, 0x7E998B13CF4E1ECC}, // 94 + {0xBFC2EF456AE276E8, 0x9E3FEDD8C321A67F}, // 95 + {0xEFB3AB16C59B14A2, 0xC5CFE94EF3EA101F}, // 96 + {0x95D04AEE3B80ECE5, 0xBBA1F1D158724A13}, // 97 + {0xBB445DA9CA61281F, 0x2A8A6E45AE8EDC98}, // 98 + {0xEA1575143CF97226, 0xF52D09D71A3293BE}, // 99 + {0x924D692CA61BE758, 0x593C2626705F9C57}, // 100 + {0xB6E0C377CFA2E12E, 0x6F8B2FB00C77836D}, // 101 + {0xE498F455C38B997A, 0x0B6DFB9C0F956448}, // 102 + {0x8EDF98B59A373FEC, 0x4724BD4189BD5EAD}, // 103 + {0xB2977EE300C50FE7, 0x58EDEC91EC2CB658}, // 104 + {0xDF3D5E9BC0F653E1, 0x2F2967B66737E3EE}, // 105 + {0x8B865B215899F46C, 0xBD79E0D20082EE75}, // 106 + {0xAE67F1E9AEC07187, 0xECD8590680A3AA12}, // 107 + {0xDA01EE641A708DE9, 0xE80E6F4820CC9496}, // 108 + {0x884134FE908658B2, 0x3109058D147FDCDE}, // 109 + {0xAA51823E34A7EEDE, 0xBD4B46F0599FD416}, // 110 + {0xD4E5E2CDC1D1EA96, 0x6C9E18AC7007C91B}, // 111 + {0x850FADC09923329E, 0x03E2CF6BC604DDB1}, // 112 + {0xA6539930BF6BFF45, 0x84DB8346B786151D}, // 113 + {0xCFE87F7CEF46FF16, 0xE612641865679A64}, // 114 + {0x81F14FAE158C5F6E, 0x4FCB7E8F3F60C07F}, // 115 + {0xA26DA3999AEF7749, 0xE3BE5E330F38F09E}, // 116 + {0xCB090C8001AB551C, 0x5CADF5BFD3072CC6}, // 117 + {0xFDCB4FA002162A63, 0x73D9732FC7C8F7F7}, // 118 + {0x9E9F11C4014DDA7E, 0x2867E7FDDCDD9AFB}, // 119 + {0xC646D63501A1511D, 0xB281E1FD541501B9}, // 120 + {0xF7D88BC24209A565, 0x1F225A7CA91A4227}, // 121 + {0x9AE757596946075F, 0x3375788DE9B06959}, // 122 + {0xC1A12D2FC3978937, 0x0052D6B1641C83AF}, // 123 + {0xF209787BB47D6B84, 0xC0678C5DBD23A49B}, // 124 + {0x9745EB4D50CE6332, 0xF840B7BA963646E1}, // 125 + {0xBD176620A501FBFF, 0xB650E5A93BC3D899}, // 126 + {0xEC5D3FA8CE427AFF, 0xA3E51F138AB4CEBF}, // 127 + {0x93BA47C980E98CDF, 0xC66F336C36B10138}, // 128 + {0xB8A8D9BBE123F017, 0xB80B0047445D4185}, // 129 + {0xE6D3102AD96CEC1D, 0xA60DC059157491E6}, // 130 + {0x9043EA1AC7E41392, 0x87C89837AD68DB30}, // 131 + {0xB454E4A179DD1877, 0x29BABE4598C311FC}, // 132 + {0xE16A1DC9D8545E94, 0xF4296DD6FEF3D67B}, // 133 + {0x8CE2529E2734BB1D, 0x1899E4A65F58660D}, // 134 + {0xB01AE745B101E9E4, 0x5EC05DCFF72E7F90}, // 135 + {0xDC21A1171D42645D, 0x76707543F4FA1F74}, // 136 + {0x899504AE72497EBA, 0x6A06494A791C53A9}, // 137 + {0xABFA45DA0EDBDE69, 0x0487DB9D17636893}, // 138 + {0xD6F8D7509292D603, 0x45A9D2845D3C42B7}, // 139 + {0x865B86925B9BC5C2, 0x0B8A2392BA45A9B3}, // 140 + {0xA7F26836F282B732, 0x8E6CAC7768D7141F}, // 141 + {0xD1EF0244AF2364FF, 0x3207D795430CD927}, // 142 + {0x8335616AED761F1F, 0x7F44E6BD49E807B9}, // 143 + {0xA402B9C5A8D3A6E7, 0x5F16206C9C6209A7}, // 144 + {0xCD036837130890A1, 0x36DBA887C37A8C10}, // 145 + {0x802221226BE55A64, 0xC2494954DA2C978A}, // 146 + {0xA02AA96B06DEB0FD, 0xF2DB9BAA10B7BD6D}, // 147 + {0xC83553C5C8965D3D, 0x6F92829494E5ACC8}, // 148 + {0xFA42A8B73ABBF48C, 0xCB772339BA1F17FA}, // 149 + {0x9C69A97284B578D7, 0xFF2A760414536EFC}, // 150 + {0xC38413CF25E2D70D, 0xFEF5138519684ABB}, // 151 + {0xF46518C2EF5B8CD1, 0x7EB258665FC25D6A}, // 152 + {0x98BF2F79D5993802, 0xEF2F773FFBD97A62}, // 153 + {0xBEEEFB584AFF8603, 0xAAFB550FFACFD8FB}, // 154 + {0xEEAABA2E5DBF6784, 0x95BA2A53F983CF39}, // 155 + {0x952AB45CFA97A0B2, 0xDD945A747BF26184}, // 156 + {0xBA756174393D88DF, 0x94F971119AEEF9E5}, // 157 + {0xE912B9D1478CEB17, 0x7A37CD5601AAB85E}, // 158 + {0x91ABB422CCB812EE, 0xAC62E055C10AB33B}, // 159 + {0xB616A12B7FE617AA, 0x577B986B314D600A}, // 160 + {0xE39C49765FDF9D94, 0xED5A7E85FDA0B80C}, // 161 + {0x8E41ADE9FBEBC27D, 0x14588F13BE847308}, // 162 + {0xB1D219647AE6B31C, 0x596EB2D8AE258FC9}, // 163 + {0xDE469FBD99A05FE3, 0x6FCA5F8ED9AEF3BC}, // 164 + {0x8AEC23D680043BEE, 0x25DE7BB9480D5855}, // 165 + {0xADA72CCC20054AE9, 0xAF561AA79A10AE6B}, // 166 + {0xD910F7FF28069DA4, 0x1B2BA1518094DA05}, // 167 + {0x87AA9AFF79042286, 0x90FB44D2F05D0843}, // 168 + {0xA99541BF57452B28, 0x353A1607AC744A54}, // 169 + {0xD3FA922F2D1675F2, 0x42889B8997915CE9}, // 170 + {0x847C9B5D7C2E09B7, 0x69956135FEBADA12}, // 171 + {0xA59BC234DB398C25, 0x43FAB9837E699096}, // 172 + {0xCF02B2C21207EF2E, 0x94F967E45E03F4BC}, // 173 + {0x8161AFB94B44F57D, 0x1D1BE0EEBAC278F6}, // 174 + {0xA1BA1BA79E1632DC, 0x6462D92A69731733}, // 175 + {0xCA28A291859BBF93, 0x7D7B8F7503CFDCFF}, // 176 + {0xFCB2CB35E702AF78, 0x5CDA735244C3D43F}, // 177 + {0x9DEFBF01B061ADAB, 0x3A0888136AFA64A8}, // 178 + {0xC56BAEC21C7A1916, 0x088AAA1845B8FDD1}, // 179 + {0xF6C69A72A3989F5B, 0x8AAD549E57273D46}, // 180 + {0x9A3C2087A63F6399, 0x36AC54E2F678864C}, // 181 + {0xC0CB28A98FCF3C7F, 0x84576A1BB416A7DE}, // 182 + {0xF0FDF2D3F3C30B9F, 0x656D44A2A11C51D6}, // 183 + {0x969EB7C47859E743, 0x9F644AE5A4B1B326}, // 184 + {0xBC4665B596706114, 0x873D5D9F0DDE1FEF}, // 185 + {0xEB57FF22FC0C7959, 0xA90CB506D155A7EB}, // 186 + {0x9316FF75DD87CBD8, 0x09A7F12442D588F3}, // 187 + {0xB7DCBF5354E9BECE, 0x0C11ED6D538AEB30}, // 188 + {0xE5D3EF282A242E81, 0x8F1668C8A86DA5FB}, // 189 + {0x8FA475791A569D10, 0xF96E017D694487BD}, // 190 + {0xB38D92D760EC4455, 0x37C981DCC395A9AD}, // 191 + {0xE070F78D3927556A, 0x85BBE253F47B1418}, // 192 + {0x8C469AB843B89562, 0x93956D7478CCEC8F}, // 193 + {0xAF58416654A6BABB, 0x387AC8D1970027B3}, // 194 + {0xDB2E51BFE9D0696A, 0x06997B05FCC0319F}, // 195 + {0x88FCF317F22241E2, 0x441FECE3BDF81F04}, // 196 + {0xAB3C2FDDEEAAD25A, 0xD527E81CAD7626C4}, // 197 + {0xD60B3BD56A5586F1, 0x8A71E223D8D3B075}, // 198 + {0x85C7056562757456, 0xF6872D5667844E4A}, // 199 + {0xA738C6BEBB12D16C, 0xB428F8AC016561DC}, // 200 + {0xD106F86E69D785C7, 0xE13336D701BEBA53}, // 201 + {0x82A45B450226B39C, 0xECC0024661173474}, // 202 + {0xA34D721642B06084, 0x27F002D7F95D0191}, // 203 + {0xCC20CE9BD35C78A5, 0x31EC038DF7B441F5}, // 204 + {0xFF290242C83396CE, 0x7E67047175A15272}, // 205 + {0x9F79A169BD203E41, 0x0F0062C6E984D387}, // 206 + {0xC75809C42C684DD1, 0x52C07B78A3E60869}, // 207 + {0xF92E0C3537826145, 0xA7709A56CCDF8A83}, // 208 + {0x9BBCC7A142B17CCB, 0x88A66076400BB692}, // 209 + {0xC2ABF989935DDBFE, 0x6ACFF893D00EA436}, // 210 + {0xF356F7EBF83552FE, 0x0583F6B8C4124D44}, // 211 + {0x98165AF37B2153DE, 0xC3727A337A8B704B}, // 212 + {0xBE1BF1B059E9A8D6, 0x744F18C0592E4C5D}, // 213 + {0xEDA2EE1C7064130C, 0x1162DEF06F79DF74}, // 214 + {0x9485D4D1C63E8BE7, 0x8ADDCB5645AC2BA9}, // 215 + {0xB9A74A0637CE2EE1, 0x6D953E2BD7173693}, // 216 + {0xE8111C87C5C1BA99, 0xC8FA8DB6CCDD0438}, // 217 + {0x910AB1D4DB9914A0, 0x1D9C9892400A22A3}, // 218 + {0xB54D5E4A127F59C8, 0x2503BEB6D00CAB4C}, // 219 + {0xE2A0B5DC971F303A, 0x2E44AE64840FD61E}, // 220 + {0x8DA471A9DE737E24, 0x5CEAECFED289E5D3}, // 221 + {0xB10D8E1456105DAD, 0x7425A83E872C5F48}, // 222 + {0xDD50F1996B947518, 0xD12F124E28F7771A}, // 223 + {0x8A5296FFE33CC92F, 0x82BD6B70D99AAA70}, // 224 + {0xACE73CBFDC0BFB7B, 0x636CC64D1001550C}, // 225 + {0xD8210BEFD30EFA5A, 0x3C47F7E05401AA4F}, // 226 + {0x8714A775E3E95C78, 0x65ACFAEC34810A72}, // 227 + {0xA8D9D1535CE3B396, 0x7F1839A741A14D0E}, // 228 + {0xD31045A8341CA07C, 0x1EDE48111209A051}, // 229 + {0x83EA2B892091E44D, 0x934AED0AAB460433}, // 230 + {0xA4E4B66B68B65D60, 0xF81DA84D56178540}, // 231 + {0xCE1DE40642E3F4B9, 0x36251260AB9D668F}, // 232 + {0x80D2AE83E9CE78F3, 0xC1D72B7C6B42601A}, // 233 + {0xA1075A24E4421730, 0xB24CF65B8612F820}, // 234 + {0xC94930AE1D529CFC, 0xDEE033F26797B628}, // 235 + {0xFB9B7CD9A4A7443C, 0x169840EF017DA3B2}, // 236 + {0x9D412E0806E88AA5, 0x8E1F289560EE864F}, // 237 + {0xC491798A08A2AD4E, 0xF1A6F2BAB92A27E3}, // 238 + {0xF5B5D7EC8ACB58A2, 0xAE10AF696774B1DC}, // 239 + {0x9991A6F3D6BF1765, 0xACCA6DA1E0A8EF2A}, // 240 + {0xBFF610B0CC6EDD3F, 0x17FD090A58D32AF4}, // 241 + {0xEFF394DCFF8A948E, 0xDDFC4B4CEF07F5B1}, // 242 + {0x95F83D0A1FB69CD9, 0x4ABDAF101564F98F}, // 243 + {0xBB764C4CA7A4440F, 0x9D6D1AD41ABE37F2}, // 244 + {0xEA53DF5FD18D5513, 0x84C86189216DC5EE}, // 245 + {0x92746B9BE2F8552C, 0x32FD3CF5B4E49BB5}, // 246 + {0xB7118682DBB66A77, 0x3FBC8C33221DC2A2}, // 247 + {0xE4D5E82392A40515, 0x0FABAF3FEAA5334B}, // 248 + {0x8F05B1163BA6832D, 0x29CB4D87F2A7400F}, // 249 + {0xB2C71D5BCA9023F8, 0x743E20E9EF511013}, // 250 + {0xDF78E4B2BD342CF6, 0x914DA9246B255417}, // 251 + {0x8BAB8EEFB6409C1A, 0x1AD089B6C2F7548F}, // 252 + {0xAE9672ABA3D0C320, 0xA184AC2473B529B2}, // 253 + {0xDA3C0F568CC4F3E8, 0xC9E5D72D90A2741F}, // 254 + {0x8865899617FB1871, 0x7E2FA67C7A658893}, // 255 + {0xAA7EEBFB9DF9DE8D, 0xDDBB901B98FEEAB8}, // 256 + {0xD51EA6FA85785631, 0x552A74227F3EA566}, // 257 + {0x8533285C936B35DE, 0xD53A88958F872760}, // 258 + {0xA67FF273B8460356, 0x8A892ABAF368F138}, // 259 + {0xD01FEF10A657842C, 0x2D2B7569B0432D86}, // 260 + {0x8213F56A67F6B29B, 0x9C3B29620E29FC74}, // 261 + {0xA298F2C501F45F42, 0x8349F3BA91B47B90}, // 262 + {0xCB3F2F7642717713, 0x241C70A936219A74}, // 263 + {0xFE0EFB53D30DD4D7, 0xED238CD383AA0111}, // 264 + {0x9EC95D1463E8A506, 0xF4363804324A40AB}, // 265 + {0xC67BB4597CE2CE48, 0xB143C6053EDCD0D6}, // 266 + {0xF81AA16FDC1B81DA, 0xDD94B7868E94050B}, // 267 + {0x9B10A4E5E9913128, 0xCA7CF2B4191C8327}, // 268 + {0xC1D4CE1F63F57D72, 0xFD1C2F611F63A3F1}, // 269 + {0xF24A01A73CF2DCCF, 0xBC633B39673C8CED}, // 270 + {0x976E41088617CA01, 0xD5BE0503E085D814}, // 271 + {0xBD49D14AA79DBC82, 0x4B2D8644D8A74E19}, // 272 + {0xEC9C459D51852BA2, 0xDDF8E7D60ED1219F}, // 273 + {0x93E1AB8252F33B45, 0xCABB90E5C942B504}, // 274 + {0xB8DA1662E7B00A17, 0x3D6A751F3B936244}, // 275 + {0xE7109BFBA19C0C9D, 0x0CC512670A783AD5}, // 276 + {0x906A617D450187E2, 0x27FB2B80668B24C6}, // 277 + {0xB484F9DC9641E9DA, 0xB1F9F660802DEDF7}, // 278 + {0xE1A63853BBD26451, 0x5E7873F8A0396974}, // 279 + {0x8D07E33455637EB2, 0xDB0B487B6423E1E9}, // 280 + {0xB049DC016ABC5E5F, 0x91CE1A9A3D2CDA63}, // 281 + {0xDC5C5301C56B75F7, 0x7641A140CC7810FC}, // 282 + {0x89B9B3E11B6329BA, 0xA9E904C87FCB0A9E}, // 283 + {0xAC2820D9623BF429, 0x546345FA9FBDCD45}, // 284 + {0xD732290FBACAF133, 0xA97C177947AD4096}, // 285 + {0x867F59A9D4BED6C0, 0x49ED8EABCCCC485E}, // 286 + {0xA81F301449EE8C70, 0x5C68F256BFFF5A75}, // 287 + {0xD226FC195C6A2F8C, 0x73832EEC6FFF3112}, // 288 + {0x83585D8FD9C25DB7, 0xC831FD53C5FF7EAC}, // 289 + {0xA42E74F3D032F525, 0xBA3E7CA8B77F5E56}, // 290 + {0xCD3A1230C43FB26F, 0x28CE1BD2E55F35EC}, // 291 + {0x80444B5E7AA7CF85, 0x7980D163CF5B81B4}, // 292 + {0xA0555E361951C366, 0xD7E105BCC3326220}, // 293 + {0xC86AB5C39FA63440, 0x8DD9472BF3FEFAA8}, // 294 + {0xFA856334878FC150, 0xB14F98F6F0FEB952}, // 295 + {0x9C935E00D4B9D8D2, 0x6ED1BF9A569F33D4}, // 296 + {0xC3B8358109E84F07, 0x0A862F80EC4700C9}, // 297 + {0xF4A642E14C6262C8, 0xCD27BB612758C0FB}, // 298 + {0x98E7E9CCCFBD7DBD, 0x8038D51CB897789D}, // 299 + {0xBF21E44003ACDD2C, 0xE0470A63E6BD56C4}, // 300 + {0xEEEA5D5004981478, 0x1858CCFCE06CAC75}, // 301 + {0x95527A5202DF0CCB, 0x0F37801E0C43EBC9}, // 302 + {0xBAA718E68396CFFD, 0xD30560258F54E6BB}, // 303 + {0xE950DF20247C83FD, 0x47C6B82EF32A206A}, // 304 + {0x91D28B7416CDD27E, 0x4CDC331D57FA5442}, // 305 + {0xB6472E511C81471D, 0xE0133FE4ADF8E953}, // 306 + {0xE3D8F9E563A198E5, 0x58180FDDD97723A7}, // 307 + {0x8E679C2F5E44FF8F, 0x570F09EAA7EA7649}, // 308 + {0xB201833B35D63F73, 0x2CD2CC6551E513DB}, // 309 + {0xDE81E40A034BCF4F, 0xF8077F7EA65E58D2}, // 310 + {0x8B112E86420F6191, 0xFB04AFAF27FAF783}, // 311 + {0xADD57A27D29339F6, 0x79C5DB9AF1F9B564}, // 312 + {0xD94AD8B1C7380874, 0x18375281AE7822BD}, // 313 + {0x87CEC76F1C830548, 0x8F2293910D0B15B6}, // 314 + {0xA9C2794AE3A3C69A, 0xB2EB3875504DDB23}, // 315 + {0xD433179D9C8CB841, 0x5FA60692A46151EC}, // 316 + {0x849FEEC281D7F328, 0xDBC7C41BA6BCD334}, // 317 + {0xA5C7EA73224DEFF3, 0x12B9B522906C0801}, // 318 + {0xCF39E50FEAE16BEF, 0xD768226B34870A01}, // 319 + {0x81842F29F2CCE375, 0xE6A1158300D46641}, // 320 + {0xA1E53AF46F801C53, 0x60495AE3C1097FD1}, // 321 + {0xCA5E89B18B602368, 0x385BB19CB14BDFC5}, // 322 + {0xFCF62C1DEE382C42, 0x46729E03DD9ED7B6}, // 323 + {0x9E19DB92B4E31BA9, 0x6C07A2C26A8346D2}, // 324 + }; + return g[k - KMIN]; +#undef KMIN +#undef KMAX +} + +#endif diff --git a/native/arm/test/xassert.h b/native/arm/test/xassert.h new file mode 100644 index 000000000..7399f3041 --- /dev/null +++ b/native/arm/test/xassert.h @@ -0,0 +1,42 @@ +/* + * Copyright 2022 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. + */ + +#ifndef XASSERT_H +#define XASSERT_H + + +#ifndef DEBUG + #define xassert(expr) ((void)0) +#else + #include "xprintf.h" + #define xassert(expr) \ + ((expr) \ + ? ((void)0) \ + : _xassert(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__)) + +static void* raise = 0; +static void xabort() { + *(int*)(raise) = 1; +} +static void _xassert(const char *assertion, const char *file, + const unsigned line, const char *func) { + xprintf("%s:%u: %s Assertion `%s' failed.\n", + file, line, func ? func : "?", assertion); + xabort(); +} +#endif // DEBUG + +#endif // XASSERT_H \ No newline at end of file diff --git a/native/arm/test/xprintf.h b/native/arm/test/xprintf.h new file mode 100644 index 000000000..5b0785f0e --- /dev/null +++ b/native/arm/test/xprintf.h @@ -0,0 +1,281 @@ +/* + * Copyright 2022 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. + */ + +#pragma once + +#include + +#ifdef LOG_LEVEL +#define DEBUG +#define LOG_TRACE(_VA_ARGS__...) do { if (LOG_LEVEL >= 0) xprintf(_VA_ARGS__ ); } while (0) +#define LOG_DEBUG(_VA_ARGS__...) do { if (LOG_LEVEL >= 1) xprintf(_VA_ARGS__ ); } while (0) +#define LOG_INFO(_VA_ARGS__...) do { if (LOG_LEVEL >= 2) xprintf(_VA_ARGS__ ); } while (0) +#else +#define LOG_TRACE(_VA_ARGS__...) ((void)0) +#define LOG_DEBUG(_VA_ARGS__...) ((void)0) +#define LOG_INFO(_VA_ARGS__...) ((void)0) +#endif + +// Note: this code is on cross-compile, so we can't use System-specific Predefined Macros here. +#if USE_APPLE +static inline void __attribute__((naked)) write_syscall(const char *s, size_t n) +{ + asm volatile( + "movq %rsi, %rdx" + "\n" + "movq %rdi, %rsi" + "\n" + "movq $1, %rdi" + "\n" + "movq $0x02000004, %rax" + "\n" + "syscall" + "\n" + "retq" + "\n"); +} +#else +static inline void __attribute__((naked)) write_syscall(const char *s, size_t n) +{ + asm volatile( + "movq %rsi, %rdx" + "\n" + "movq %rdi, %rsi" + "\n" + "movq $1, %rdi" + "\n" + "movq $1, %rax" + "\n" + "syscall" + "\n" + "retq" + "\n"); +} +#endif + +static inline void printch(const char ch) +{ + write_syscall(&ch, 1); +} + +static inline void printstr(const char *s) +{ + size_t n = 0; + const char *p = s; + while (*p++) + n++; + write_syscall(s, n); +} + +static inline void printint(int64_t v) +{ + char neg = 0; + char buf[32] = {}; + char *p = &buf[31]; + uint64_t u; + if (v < 0) { + u = ~v + 1; + neg = 1; + } else { + u = v; + } + if (u == 0) { + *--p = '0'; + goto sig; + } + while (u) + { + *--p = (u % 10) + '0'; + u /= 10; + } +sig: + if (neg) { + *--p = '-'; + } + printstr(p); +} + +static inline void printuint(uint64_t v) +{ + char buf[32] = {}; + char *p = &buf[31]; + if (v == 0) + { + printch('0'); + return; + } + while (v) + { + *--p = (v % 10) + '0'; + v /= 10; + } + printstr(p); +} + +static const char tab[] = "0123456789abcdef"; + +static inline void printhex(uintptr_t v) +{ + if (v == 0) + { + printch('0'); + return; + } + char buf[32] = {}; + char *p = &buf[31]; + + while (v) + { + *--p = tab[v & 0x0f]; + v >>= 4; + } + printstr(p); +} + +#define MAX_BUF_LEN 1000 + +static inline void printbytes(GoSlice *s) +{ + printch('['); + int i = 0; + if (s->len > MAX_BUF_LEN) + { + i = s->len - MAX_BUF_LEN; + } + for (; i < s->len; i++) + { + char* bytes = (char*)(s->buf); + printch(tab[(bytes[i] & 0xf0) >> 4]); + printch(tab[bytes[i] & 0x0f]); + if (i != s->len - 1) + printch(','); + } + printch(']'); +} + +static inline void printgostr(GoString *s) +{ + printch('"'); + if (s->len < MAX_BUF_LEN) + { + write_syscall(s->buf, s->len); + } + else + { + write_syscall(s->buf, MAX_BUF_LEN); + } + printch('"'); +} + +static inline void do_xprintf(const char *fmt, ...) +{ + __builtin_va_list va; + char buf[256] = {}; + char *p = buf; + __builtin_va_start(va, fmt); + for (;;) + { + if (*fmt == 0) + { + break; + } + if (*fmt != '%') + { + *p++ = *fmt++; + continue; + } + *p = 0; + p = buf; + fmt++; + printstr(buf); + switch (*fmt++) + { + case '%': + { + printch('%'); + break; + } + case 'g': + { + printgostr(__builtin_va_arg(va, GoString *)); + break; + } + case 's': + { + printstr(__builtin_va_arg(va, const char *)); + break; + } + case 'd': + { + printint(__builtin_va_arg(va, int64_t)); + break; + } + case 'u': + { + printuint(__builtin_va_arg(va, uint64_t)); + break; + } + case 'f': + { + printint(__builtin_va_arg(va, double)); + break; + } + case 'c': + { + printch((char)(__builtin_va_arg(va, int))); + break; + } + case 'x': + { + printhex(__builtin_va_arg(va, uintptr_t)); + break; + } + case 'l': + { + printbytes(__builtin_va_arg(va, GoSlice *)); + break; + } + } + } + __builtin_va_end(va); + if (p != buf) + { + *p = 0; + printstr(buf); + } +} + +#ifdef DEBUG +#define xprintf(_VA_ARGS__...) do_xprintf(_VA_ARGS__) +#else +#define xprintf(_VA_ARGS__...) ((void)0) +#endif + +static always_inline void print_longhex(const void *input, const char* s, int bytes) { + const uint8_t* p = (const uint8_t*)(input); + xprintf("%s : ", s); + for (int i = 0; i < bytes; i++) { + uintptr_t u = p[i]; + if (u < 0x10) xprintf("0"); + xprintf("%x", u); + if ((i + 1) < bytes && (i + 1) % 4 == 0) { + xprintf("-"); + } + } + xprintf("\n"); +} + +#define psimd(simd) print_longhex((const void *)(simd), #simd, sizeof(*simd)) \ No newline at end of file diff --git a/native/arm/types.h b/native/arm/types.h new file mode 100644 index 000000000..196923b09 --- /dev/null +++ b/native/arm/types.h @@ -0,0 +1,45 @@ + +#ifndef TYPES_H +#define TYPES_H + +// NOTE: !NOT MODIFIED ONLY. +// This definitions are copied from internal/native/types/types.go. + +#define V_EOF 1 +#define V_NULL 2 +#define V_TRUE 3 +#define V_FALSE 4 +#define V_ARRAY 5 +#define V_OBJECT 6 +#define V_STRING 7 +#define V_DOUBLE 8 +#define V_INTEGER 9 +#define V_KEY_SEP 10 +#define V_ELEM_SEP 11 +#define V_ARRAY_END 12 +#define V_OBJECT_END 13 + +#define F_DBLUNQ (1 << 0) +#define F_UNIREP (1 << 1) + +#define VS_NULL 0x6c6c756e // 'null' in little endian +#define VS_TRUE 0x65757274 // 'true' in little endian +#define VS_ALSE 0x65736c61 // 'alse' in little endian ('false' without the 'f') + +#define ERR_EOF 1 +#define ERR_INVAL 2 +#define ERR_ESCAPE 3 +#define ERR_UNICODE 4 +#define ERR_OVERFLOW 5 +#define ERR_NUMBER_FMT 6 +#define ERR_RECURSE_MAX 7 +#define ERR_FLOAT_INF 8 +#define ERR_MISMATCH 9 +#define ERR_INVAL_UTF8 10 + +#define ERR_NOT_FOUND 33 +#define ERR_UNSUPPORT_TYPE 34 + +#define MAX_RECURSE 4096 + +#endif diff --git a/native/arm/u64toa.c b/native/arm/u64toa.c new file mode 100644 index 000000000..30a119c3a --- /dev/null +++ b/native/arm/u64toa.c @@ -0,0 +1,6 @@ +#include "fastint.h" + + +int u64toa(char *out, uint64_t val) { + return u64toa_1(out, val); +} diff --git a/native/arm/unquote.c b/native/arm/unquote.c new file mode 100644 index 000000000..f707a4b3f --- /dev/null +++ b/native/arm/unquote.c @@ -0,0 +1,201 @@ +#include "parsing.h" + + +ssize_t unquote(const char *sp, ssize_t nb, char *dp, ssize_t *ep, uint64_t flags) { + ssize_t n; + ssize_t x = nb; + const char * s = sp; + const char * p = dp; + + /* scan & copy all the non-escape characters */ + while (nb && (n = (*sp == '\\' ? 0 : memcchr_p32(sp, nb, dp))) != -1) { + char cc; + uint32_t r0; + uint32_t r1; + + /* skip the plain text */ + dp += n; + sp += n + 2; + nb -= n + 2; + + /* check for EOF */ + if (nb < 0) { + *ep = x; + return -ERR_EOF; + } + + /* check for double unquote */ + if (unlikely(flags & F_DBLUNQ)) { + int nr = nb; + char c1 = sp[-1]; + + /* must have at least 1 character left */ + if (nr == 0) { + *ep = x; + return -ERR_EOF; + } + + /* every quote must be a double quote */ + if (c1 != '\\') { + *ep = sp - s - 1; + return -ERR_INVAL; + } + + /* special case of '\\\\' and '\\\"' */ + if (*sp == '\\') { + if (nr < 2) { + *ep = x; + return -ERR_EOF; + } else if (sp[1] != '"' && sp[1] != '\\') { + *ep = sp - s + 1; + return -ERR_INVAL; + } else { + sp++; + nb--; + } + } + + /* skip the second escape */ + sp++; + nb--; + } + + /* check for escape sequence */ + if ((cc = _UnquoteTab[(uint8_t)sp[-1]]) == 0) { + *ep = sp - s - 1; + return -ERR_ESCAPE; + } + + /* check for simple escape sequence */ + if (cc != -1) { + *dp++ = cc; + continue; + } + + /* must have at least 4 characters */ + if (nb < 4) { + *ep = x; + return -ERR_EOF; + } + + /* check for hexadecimal characters */ + if (!unhex16_is(sp)) { + *ep = sp - s; + for (int i = 0; i < 4 && ishex(*sp); i++, sp++) ++*ep; + return -ERR_INVAL; + } + + /* decode the code-point */ + r0 = unhex16_fast(sp); + sp += 4; + nb -= 4; + + /* from line 598 */ + retry_decode: + + /* ASCII characters, unlikely */ + if (unlikely(r0 <= 0x7f)) { + *dp++ = (char)r0; + continue; + } + + /* latin-1 characters, unlikely */ + if (unlikely(r0 <= 0x07ff)) { + *dp++ = (char)(0xc0 | (r0 >> 6)); + *dp++ = (char)(0x80 | (r0 & 0x3f)); + continue; + } + + /* 3-byte characters, likely */ + if (likely(r0 < 0xd800 || r0 > 0xdfff)) { + *dp++ = (char)(0xe0 | ((r0 >> 12) )); + *dp++ = (char)(0x80 | ((r0 >> 6) & 0x3f)); + *dp++ = (char)(0x80 | ((r0 ) & 0x3f)); + continue; + } + + /* check for double unquote */ + if (unlikely(flags & F_DBLUNQ)) { + if (nb < 1) { + if (likely(flags & F_UNIREP)) { + unirep(&dp); + continue; + } else { + *ep = x; + return -ERR_EOF; + } + } else { + if (sp[0] == '\\') { + nb--; + sp++; + } else if (likely(flags & F_UNIREP)) { + unirep(&dp); + continue; + } else { + *ep = sp - s - 4; + return -ERR_UNICODE; + } + } + } + + /* surrogate half, must follows by the other half */ + if (nb < 6 || r0 > 0xdbff || sp[0] != '\\' || sp[1] != 'u') { + if (likely(flags & F_UNIREP)) { + unirep(&dp); + continue; + } else { + *ep = sp - s - ((flags & F_DBLUNQ) ? 5 : 4); + return -ERR_UNICODE; + } + } + + /* check the hexadecimal escape */ + if (!unhex16_is(sp + 2)) { + *ep = sp - s + 2; + for (int i = 2; i < 6 && ishex(sp[i]); i++) ++*ep; + return -ERR_INVAL; + } + + /* decode the second code-point */ + r1 = unhex16_fast(sp + 2); + sp += 6; + nb -= 6; + + /* it must be the other half */ + if (r1 < 0xdc00 || r1 > 0xdfff) { + if (unlikely(!(flags & F_UNIREP))) { + *ep = sp - s - 4; + return -ERR_UNICODE; + } else { + r0 = r1; + unirep(&dp); + goto retry_decode; + } + } + + /* merge two surrogates */ + r0 = (r0 - 0xd800) << 10; + r1 = (r1 - 0xdc00) + 0x010000; + r0 += r1; + + /* check the code point range */ + if (r0 > 0x10ffff) { + if (likely(!(flags & F_UNIREP))) { + *ep = sp - s - 4; + return -ERR_UNICODE; + } else { + unirep(&dp); + continue; + } + } + + /* encode the character */ + *dp++ = (char)(0xf0 | ((r0 >> 18) )); + *dp++ = (char)(0x80 | ((r0 >> 12) & 0x3f)); + *dp++ = (char)(0x80 | ((r0 >> 6) & 0x3f)); + *dp++ = (char)(0x80 | ((r0 ) & 0x3f)); + } + + /* calculate the result length */ + return dp + nb - p; +} \ No newline at end of file diff --git a/native/arm/utf8.h b/native/arm/utf8.h new file mode 100644 index 000000000..73a988ca9 --- /dev/null +++ b/native/arm/utf8.h @@ -0,0 +1,493 @@ +/* + * Copyright (C) 2019 Yaoyuan . + * + * 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. + * + * Copyright 2018-2023 The simdjson authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + + * http://www.apache.org/licenses/LICENSE-2.0 + + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * This file may have been modified by ByteDance authors. All ByteDance + * Modifications are Copyright 2022 ByteDance Authors. + */ + +#pragma once + +#include "native.h" +#include "utils.h" +#include "test/xassert.h" +#include "test/xprintf.h" + +static inline ssize_t valid_utf8_4byte(uint32_t ubin) { + /* + Each unicode code point is encoded as 1 to 4 bytes in UTF-8 encoding, + we use 4-byte mask and pattern value to validate UTF-8 byte sequence, + this requires the input data to have 4-byte zero padding. + --------------------------------------------------- + 1 byte + unicode range [U+0000, U+007F] + unicode min [.......0] + unicode max [.1111111] + bit pattern [0.......] + --------------------------------------------------- + 2 byte + unicode range [U+0080, U+07FF] + unicode min [......10 ..000000] + unicode max [...11111 ..111111] + bit require [...xxxx. ........] (1E 00) + bit mask [xxx..... xx......] (E0 C0) + bit pattern [110..... 10......] (C0 80) + // 1101 0100 10110000 + // 0001 1110 + --------------------------------------------------- + 3 byte + unicode range [U+0800, U+FFFF] + unicode min [........ ..100000 ..000000] + unicode max [....1111 ..111111 ..111111] + bit require [....xxxx ..x..... ........] (0F 20 00) + bit mask [xxxx.... xx...... xx......] (F0 C0 C0) + bit pattern [1110.... 10...... 10......] (E0 80 80) + --------------------------------------------------- + 3 byte invalid (reserved for surrogate halves) + unicode range [U+D800, U+DFFF] + unicode min [....1101 ..100000 ..000000] + unicode max [....1101 ..111111 ..111111] + bit mask [....xxxx ..x..... ........] (0F 20 00) + bit pattern [....1101 ..1..... ........] (0D 20 00) + --------------------------------------------------- + 4 byte + unicode range [U+10000, U+10FFFF] + unicode min [........ ...10000 ..000000 ..000000] + unicode max [.....100 ..001111 ..111111 ..111111] + bit err0 [.....100 ........ ........ ........] (04 00 00 00) + bit err1 [.....011 ..110000 ........ ........] (03 30 00 00) + bit require [.....xxx ..xx.... ........ ........] (07 30 00 00) + bit mask [xxxxx... xx...... xx...... xx......] (F8 C0 C0 C0) + bit pattern [11110... 10...... 10...... 10......] (F0 80 80 80) + --------------------------------------------------- + */ + const uint32_t b2_mask = 0x0000C0E0UL; + const uint32_t b2_patt = 0x000080C0UL; + const uint32_t b2_requ = 0x0000001EUL; + const uint32_t b3_mask = 0x00C0C0F0UL; + const uint32_t b3_patt = 0x008080E0UL; + const uint32_t b3_requ = 0x0000200FUL; + const uint32_t b3_erro = 0x0000200DUL; + const uint32_t b4_mask = 0xC0C0C0F8UL; + const uint32_t b4_patt = 0x808080F0UL; + const uint32_t b4_requ = 0x00003007UL; + const uint32_t b4_err0 = 0x00000004UL; + const uint32_t b4_err1 = 0x00003003UL; + +#define is_valid_seq_2(uni) ( \ + ((uni & b2_mask) == b2_patt) && \ + ((uni & b2_requ)) \ +) + +#define is_valid_seq_3(uni) ( \ + ((uni & b3_mask) == b3_patt) && \ + ((tmp = (uni & b3_requ))) && \ + ((tmp != b3_erro)) \ +) + +#define is_valid_seq_4(uni) ( \ + ((uni & b4_mask) == b4_patt) && \ + ((tmp = (uni & b4_requ))) && \ + ((tmp & b4_err0) == 0 || (tmp & b4_err1) == 0) \ +) + uint32_t tmp = 0; + + if (is_valid_seq_3(ubin)) return 3; + if (is_valid_seq_2(ubin)) return 2; + if (is_valid_seq_4(ubin)) return 4; + return 0; +} + +static always_inline long write_error(int pos, StateMachine *m, size_t msize) { + if (m->sp >= msize) { + return -1; + } + m->vt[m->sp++] = pos; + return 0; +} + +// scalar code, error position should excesss 4096 +static always_inline long validate_utf8_with_errors(const char *src, long len, long *p, StateMachine *m) { + const char* start = src + *p; + const char* end = src + len; + while (start < end - 3) { + uint32_t u = (*(uint32_t*)(start)); + if ((unsigned)(*start) < 0x80) { + start += 1; + continue; + } + size_t n = valid_utf8_4byte(u); + if (n != 0) { // valid utf + start += n; + continue; + } + long err = write_error(start - src, m, MAX_RECURSE); + if (err) { + *p = start - src; + return err; + } + start += 1; + } + while (start < end) { + if ((unsigned)(*start) < 0x80) { + start += 1; + continue; + } + uint32_t u = 0; + memcpy_p4(&u, start, end - start); + size_t n = valid_utf8_4byte(u); + if (n != 0) { // valid utf + start += n; + continue; + } + long err = write_error(start - src, m, MAX_RECURSE); + if (err) { + *p = start - src; + return err; + } + start += 1; + } + *p = start - src; + return 0; +} + +// validate_utf8_errors returns zero if valid, otherwise, the error position. +static always_inline long validate_utf8_errors(const GoString* s) { + const char* start = s->buf; + const char* end = s->buf + s->len; + while (start < end - 3) { + uint32_t u = (*(uint32_t*)(start)); + if ((unsigned)(*start) < 0x80) { + start += 1; + continue; + } + size_t n = valid_utf8_4byte(u); + if (n == 0) { // invalid utf + return -(start - s->buf) - 1; + } + start += n; + } + while (start < end) { + if ((unsigned)(*start) < 0x80) { + start += 1; + continue; + } + uint32_t u = 0; + memcpy_p4(&u, start, end - start); + size_t n = valid_utf8_4byte(u); + if (n == 0) { // invalid utf + return -(start - s->buf) - 1; + } + start += n; + } + return 0; +} + +// SIMD implementation +#if USE_AVX2 + + static always_inline __m256i simd256_shr(const __m256i input, const int shift) { + __m256i shifted = _mm256_srli_epi16(input, shift); + __m256i mask = _mm256_set1_epi8(0xFFu >> shift); + return _mm256_and_si256(shifted, mask); + } + +#define simd256_prev(input, prev, N) _mm256_alignr_epi8(input, _mm256_permute2x128_si256(prev, input, 0x21), 16 - (N)); + + static always_inline __m256i must_be_2_3_continuation(const __m256i prev2, const __m256i prev3) { + __m256i is_third_byte = _mm256_subs_epu8(prev2, _mm256_set1_epi8(0b11100000u-1)); // Only 111_____ will be > 0 + __m256i is_fourth_byte = _mm256_subs_epu8(prev3, _mm256_set1_epi8(0b11110000u-1)); // Only 1111____ will be > 0 + // Caller requires a bool (all 1's). All values resulting from the subtraction will be <= 64, so signed comparison is fine. + __m256i or = _mm256_or_si256(is_third_byte, is_fourth_byte); + return _mm256_cmpgt_epi8(or, _mm256_set1_epi8(0));; + } + + static always_inline __m256i simd256_lookup16(const __m256i input, const uint8_t* table) { + return _mm256_shuffle_epi8(_mm256_setr_epi8(table[0], table[1], table[2], table[3], table[4], table[5], table[6], table[7], table[8], table[9], table[10], table[11], table[12], table[13], table[14], table[15], table[0], table[1], table[2], table[3], table[4], table[5], table[6], table[7], table[8], table[9], table[10], table[11], table[12], table[13], table[14], table[15]), input); + } + + // + // Return nonzero if there are incomplete multibyte characters at the end of the block: + // e.g. if there is a 4-byte character, but it's 3 bytes from the end. + // + static always_inline __m256i is_incomplete(const __m256i input) { + // If the previous input's last 3 bytes match this, they're too short (they ended at EOF): + // ... 1111____ 111_____ 11______ + const uint8_t tab[32] = { + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 0b11110000u-1, 0b11100000u-1, 0b11000000u-1}; + const __m256i max_value = _mm256_loadu_si256((const __m256i_u *)(&tab[0])); + return _mm256_subs_epu8(input, max_value); + } + + static always_inline __m256i check_special_cases(const __m256i input, const __m256i prev1) { + // Bit 0 = Too Short (lead byte/ASCII followed by lead byte/ASCII) + // Bit 1 = Too Long (ASCII followed by continuation) + // Bit 2 = Overlong 3-byte + // Bit 4 = Surrogate + // Bit 5 = Overlong 2-byte + // Bit 7 = Two Continuations + const uint8_t TOO_SHORT = 1<<0; // 11______ 0_______ + // 11______ 11______ + const uint8_t TOO_LONG = 1<<1; // 0_______ 10______ + const uint8_t OVERLONG_3 = 1<<2; // 11100000 100_____ + const uint8_t SURROGATE = 1<<4; // 11101101 101_____ + const uint8_t OVERLONG_2 = 1<<5; // 1100000_ 10______ + const uint8_t TWO_CONTS = 1<<7; // 10______ 10______ + const uint8_t TOO_LARGE = 1<<3; // 11110100 1001____ + // 11110100 101_____ + // 11110101 1001____ + // 11110101 101_____ + // 1111011_ 1001____ + // 1111011_ 101_____ + // 11111___ 1001____ + // 11111___ 101_____ + const uint8_t TOO_LARGE_1000 = 1<<6; + // 11110101 1000____ + // 1111011_ 1000____ + // 11111___ 1000____ + const uint8_t OVERLONG_4 = 1<<6; // 11110000 1000____ + + const __m256i prev1_shr4 = simd256_shr(prev1, 4); + static const uint8_t tab1[16] = { + // 0_______ ________ + TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, + TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, + // 10______ ________ + TWO_CONTS, TWO_CONTS, TWO_CONTS, TWO_CONTS, + // 1100____ ________ + TOO_SHORT | OVERLONG_2, + // 1101____ ________ + TOO_SHORT, + // 1110____ ________ + TOO_SHORT | OVERLONG_3 | SURROGATE, + // 1111____ ________ + TOO_SHORT | TOO_LARGE | TOO_LARGE_1000 | OVERLONG_4, + }; + __m256i byte_1_high = simd256_lookup16(prev1_shr4, tab1); + + + const uint8_t CARRY = TOO_SHORT | TOO_LONG | TWO_CONTS; // These all have ____ in byte 1 . + __m256i prev1_low = _mm256_and_si256(prev1, _mm256_set1_epi8(0x0F)); + static const uint8_t tab2[16] = { + // ____0000 ________ + CARRY | OVERLONG_3 | OVERLONG_2 | OVERLONG_4, + // ____0001 ________ + CARRY | OVERLONG_2, + // ____001_ ________ + CARRY, + CARRY, + + // ____0100 ________ + CARRY | TOO_LARGE, + // ____0101 ________ + CARRY | TOO_LARGE | TOO_LARGE_1000, + // ____011_ ________ + CARRY | TOO_LARGE | TOO_LARGE_1000, + CARRY | TOO_LARGE | TOO_LARGE_1000, + + // ____1___ ________ + CARRY | TOO_LARGE | TOO_LARGE_1000, + CARRY | TOO_LARGE | TOO_LARGE_1000, + CARRY | TOO_LARGE | TOO_LARGE_1000, + CARRY | TOO_LARGE | TOO_LARGE_1000, + CARRY | TOO_LARGE | TOO_LARGE_1000, + // ____1101 ________ + CARRY | TOO_LARGE | TOO_LARGE_1000 | SURROGATE, + CARRY | TOO_LARGE | TOO_LARGE_1000, + CARRY | TOO_LARGE | TOO_LARGE_1000 + }; + __m256i byte_1_low = simd256_lookup16(prev1_low, tab2); + + + const __m256i input_shr4 = simd256_shr(input, 4); + static const uint8_t tab3[16] = { + // ________ 0_______ + TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT, + TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT, + + // ________ 1000____ + TOO_LONG | OVERLONG_2 | TWO_CONTS | OVERLONG_3 | TOO_LARGE_1000 | OVERLONG_4, + // ________ 1001____ + TOO_LONG | OVERLONG_2 | TWO_CONTS | OVERLONG_3 | TOO_LARGE, + // ________ 101_____ + TOO_LONG | OVERLONG_2 | TWO_CONTS | SURROGATE | TOO_LARGE, + TOO_LONG | OVERLONG_2 | TWO_CONTS | SURROGATE | TOO_LARGE, + + // ________ 11______ + TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT + }; + __m256i byte_2_high = simd256_lookup16(input_shr4, tab3); + + + return _mm256_and_si256(_mm256_and_si256(byte_1_high, byte_1_low), byte_2_high); + } + + static always_inline __m256i check_multibyte_lengths(const __m256i input, const __m256i prev_input, const __m256i sc) { + __m256i prev2 = simd256_prev(input, prev_input, 2); + __m256i prev3 = simd256_prev(input, prev_input, 3); + + + __m256i must23 = must_be_2_3_continuation(prev2, prev3); + + __m256i must23_80 = _mm256_and_si256(must23, _mm256_set1_epi8(0x80)); + + return _mm256_xor_si256(must23_80, sc); + } + + + // Check whether the current bytes are valid UTF-8. + static always_inline __m256i check_utf8_bytes(const __m256i input, const __m256i prev_input) { + // Flip prev1...prev3 so we can easily determine if they are 2+, 3+ or 4+ lead bytes + // (2, 3, 4-byte leads become large positive numbers instead of small negative numbers) + __m256i prev1 = simd256_prev(input, prev_input, 1); + __m256i sc = check_special_cases(input, prev1); + __m256i ret = check_multibyte_lengths(input, prev_input, sc); + return ret; + } + + static always_inline bool is_ascii(const __m256i input) { + return _mm256_movemask_epi8(input) == 0; + } + + typedef struct { + // If this is nonzero, there has been a UTF-8 error. + __m256i error; + // The last input we received + __m256i prev_input_block; + // Whether the last input we received was incomplete (used for ASCII fast path) + __m256i prev_incomplete; + } utf8_checker; + + static always_inline void utf8_checker_init(utf8_checker* checker) { + checker->error = _mm256_setzero_si256(); + checker->prev_input_block = _mm256_setzero_si256(); + checker->prev_incomplete = _mm256_setzero_si256(); + } + + static always_inline bool check_error(utf8_checker* checker) { + return !_mm256_testz_si256(checker->error, checker->error); + } + + static always_inline void check64_utf(utf8_checker* checker, const uint8_t* start) { + __m256i input = _mm256_loadu_si256((__m256i*)start); + __m256i input2 = _mm256_loadu_si256((__m256i*)(start + 32)); + // check utf-8 chars + __m256i error1 = check_utf8_bytes(input, checker->prev_input_block); + __m256i error2 = check_utf8_bytes(input2, input); + checker->error = _mm256_or_si256(checker->error, _mm256_or_si256(error1, error2)); + checker->prev_input_block = input2; + checker->prev_incomplete = is_incomplete(input2); + } + + static always_inline void check64(utf8_checker* checker, const uint8_t* start) { + // fast path for contiguous ASCII + __m256i input = _mm256_loadu_si256((__m256i*)start); + __m256i input2 = _mm256_loadu_si256((__m256i*)(start + 32)); + __m256i reducer = _mm256_or_si256(input, input2); + // check utf-8 + if (likely(is_ascii(reducer))) { + checker->error = _mm256_or_si256(checker->error, checker->prev_incomplete); + return; + } + check64_utf(checker, start); + } + + static always_inline void check128(utf8_checker* checker, const uint8_t* start) { + // fast path for contiguous ASCII + __m256i input = _mm256_loadu_si256((__m256i*)start); + __m256i input2 = _mm256_loadu_si256((__m256i*)(start + 32)); + __m256i input3 = _mm256_loadu_si256((__m256i*)(start + 64)); + __m256i input4 = _mm256_loadu_si256((__m256i*)(start + 96)); + + __m256i reducer1 = _mm256_or_si256(input, input2); + __m256i reducer2 = _mm256_or_si256(input3, input4); + __m256i reducer = _mm256_or_si256(reducer1, reducer2); + + // full 128 bytes are ascii + if (likely(is_ascii(reducer))) { + checker->error = _mm256_or_si256(checker->error, checker->prev_incomplete); + return; + } + + // frist 64 bytes is ascii, next 64 bytes must be utf8 + if (likely(is_ascii(reducer1))) { + checker->error = _mm256_or_si256(checker->error, checker->prev_incomplete); + check64_utf(checker, start + 64); + return; + } + + // frist 64 bytes has utf8, next 64 bytes + check64_utf(checker, start); + if (unlikely(is_ascii(reducer2))) { + checker->error = _mm256_or_si256(checker->error, checker->prev_incomplete); + } else { + check64_utf(checker, start + 64); + } + } + + static always_inline void check_eof(utf8_checker* checker) { + checker->error = _mm256_or_si256(checker->error, checker->prev_incomplete); + } + + static always_inline void check_remain(utf8_checker* checker, const uint8_t* start, const uint8_t* end) { + uint8_t buffer[64] = {0}; + int i = 0; + while (start < end) { + buffer[i++] = *(start++); + }; + check64(checker, buffer); + check_eof(checker); + } + + static always_inline long validate_utf8_avx2(const GoString* s) { + xassert(s->buf != NULL || s->len != 0); + const uint8_t* start = (const uint8_t*)(s->buf); + const uint8_t* end = (const uint8_t*)(s->buf + s->len); + /* check eof */ + if (s->len == 0) { + return 0; + } + utf8_checker checker; + utf8_checker_init(&checker); + while (start < (end - 128)) { + check128(&checker, start); + if (check_error(&checker)) { + } + start += 128; + }; + while (start < end - 64) { + check64(&checker, start); + start += 64; + } + check_remain(&checker, start, end); + return check_error(&checker) ? -1 : 0; + } +#endif diff --git a/native/arm/utils.h b/native/arm/utils.h new file mode 100644 index 000000000..3ae862677 --- /dev/null +++ b/native/arm/utils.h @@ -0,0 +1,77 @@ +/* + * Copyright 2022 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. + */ + +#pragma once + +#include +#include "native.h" + +static always_inline bool vec_cross_page(const void * p, size_t n) { +#define PAGE_SIZE 4096 + return (((size_t)(p)) & (PAGE_SIZE - 1)) > (PAGE_SIZE - n); +#undef PAGE_SIZE +} + +static always_inline void memcpy4 (void *__restrict dp, const void *__restrict sp) { + ((uint32_t *)dp)[0] = ((const uint32_t *)sp)[0]; +} + +static always_inline void memcpy8 (void *__restrict dp, const void *__restrict sp) { + ((uint64_t *)dp)[0] = ((const uint64_t *)sp)[0]; +} + +static always_inline void memcpy16 (void *__restrict dp, const void *__restrict sp) { + _mm_storeu_si128((void *)(dp), _mm_loadu_si128((const void *)(sp))); +} + +static always_inline void memcpy32(void *__restrict dp, const void *__restrict sp) { +#if USE_AVX2 + _mm256_storeu_si256((void *)dp, _mm256_loadu_si256((const void *)sp)); +#else + _mm_storeu_si128((void *)(dp), _mm_loadu_si128((const void *)(sp))); + _mm_storeu_si128((void *)(dp + 16), _mm_loadu_si128((const void *)(sp + 16))); +#endif +} + +static always_inline void memcpy64(void *__restrict dp, const void *__restrict sp) { + memcpy32(dp, sp); + memcpy32(dp + 32, sp + 32); +} + +static always_inline void memcpy_p4(void *__restrict dp, const void *__restrict sp, size_t nb) { + if (nb >= 2) { *(uint16_t *)dp = *(const uint16_t *)sp; sp += 2, dp += 2, nb -= 2; } + if (nb >= 1) { *(uint8_t *) dp = *(const uint8_t *)sp; } +} + +static always_inline void memcpy_p8(void *__restrict dp, const void *__restrict sp, ssize_t nb) { + if (nb >= 4) { memcpy4(dp, sp); sp += 4, dp += 4, nb -= 4; } + memcpy_p4(dp, sp, nb); +} + +static always_inline void memcpy_p16(void *__restrict dp, const void *__restrict sp, size_t nb) { + if (nb >= 8) { memcpy8(dp, sp); sp += 8, dp += 8, nb -= 8; } + memcpy_p8(dp, sp, nb); +} + +static always_inline void memcpy_p32(void *__restrict dp, const void *__restrict sp, size_t nb) { + if (nb >= 16) { memcpy16(dp, sp); sp += 16, dp += 16, nb -= 16; } + memcpy_p16(dp, sp, nb); +} + +static always_inline void memcpy_p64(void *__restrict dp, const void *__restrict sp, size_t nb) { + if (nb >= 32) { memcpy32(dp, sp); sp += 32, dp += 32, nb -= 32; } + memcpy_p32(dp, sp, nb); +} diff --git a/native/arm/validate_one.c b/native/arm/validate_one.c new file mode 100644 index 000000000..5f346d83c --- /dev/null +++ b/native/arm/validate_one.c @@ -0,0 +1,6 @@ +#include "scanning.h" + +long validate_one(const GoString *src, long *p, StateMachine *m) { + fsm_init(m, FSM_VAL); + return fsm_exec_1(m, src, p, MASK_VALIDATE_STRING); +} diff --git a/native/arm/validate_utf8.c b/native/arm/validate_utf8.c new file mode 100644 index 000000000..3955b0447 --- /dev/null +++ b/native/arm/validate_utf8.c @@ -0,0 +1,6 @@ +#include "scanning.h" + +long validate_utf8(const GoString *src, long *p, StateMachine *m) { + xassert(*p >= 0 && src->len > *p); + return validate_utf8_with_errors(src->buf, src->len, p, m); +} \ No newline at end of file diff --git a/native/arm/validate_utf8_fast.c b/native/arm/validate_utf8_fast.c new file mode 100644 index 000000000..b8be63f62 --- /dev/null +++ b/native/arm/validate_utf8_fast.c @@ -0,0 +1,12 @@ +#include "scanning.h" + +// validate_utf8_fast returns zero if valid, otherwise, the error position. +long validate_utf8_fast(const GoString *s) { +#if USE_AVX2 + /* fast path for valid utf8 */ + if (validate_utf8_avx2(s) == 0) { + return 0; + } +#endif + return validate_utf8_errors(s); +} \ No newline at end of file diff --git a/native/arm/value.c b/native/arm/value.c new file mode 100644 index 000000000..a6fa9c44f --- /dev/null +++ b/native/arm/value.c @@ -0,0 +1,34 @@ +#include "scanning.h" +#include "vstring.h" + +long value(const char *s, size_t n, long p, JsonState *ret, uint64_t flags) { + long q = p; + GoString m = {.buf = s, .len = n}; + bool allow_control = (flags & MASK_ALLOW_CONTROL) != 0; + /* parse the next identifier, q is UNSAFE, may cause out-of-bounds accessing */ + switch (advance_ns(&m, &q)) { + case '-' : /* fallthrough */ + case '0' : /* fallthrough */ + case '1' : /* fallthrough */ + case '2' : /* fallthrough */ + case '3' : /* fallthrough */ + case '4' : /* fallthrough */ + case '5' : /* fallthrough */ + case '6' : /* fallthrough */ + case '7' : /* fallthrough */ + case '8' : /* fallthrough */ + case '9' : vdigits(&m, &q, ret, flags) ; return q; + case '"' : vstring_1(&m, &q, ret, flags) ; return q; + case 'n' : ret->vt = advance_dword(&m, &q, 1, V_NULL, VS_NULL) ; return q; + case 't' : ret->vt = advance_dword(&m, &q, 1, V_TRUE, VS_TRUE) ; return q; + case 'f' : ret->vt = advance_dword(&m, &q, 0, V_FALSE, VS_ALSE) ; return q; + case '[' : ret->vt = V_ARRAY ; return q; + case '{' : ret->vt = V_OBJECT ; return q; + case ':' : ret->vt = allow_control ? V_KEY_SEP : -ERR_INVAL ; return allow_control ? q : q - 1; + case ',' : ret->vt = allow_control ? V_ELEM_SEP : -ERR_INVAL ; return allow_control ? q : q - 1; + case ']' : ret->vt = allow_control ? V_ARRAY_END : -ERR_INVAL ; return allow_control ? q : q - 1; + case '}' : ret->vt = allow_control ? V_OBJECT_END : -ERR_INVAL ; return allow_control ? q : q - 1; + case 0 : ret->vt = V_EOF ; return q; + default : ret->vt = -ERR_INVAL ; return q - 1; + } +} diff --git a/native/arm/vnumber.c b/native/arm/vnumber.c new file mode 100644 index 000000000..a2d42ad99 --- /dev/null +++ b/native/arm/vnumber.c @@ -0,0 +1,6 @@ +#include "scanning.h" + + +void vnumber(const GoString *src, long *p, JsonState *ret) { + return vnumber_1(src, p, ret); +} \ No newline at end of file diff --git a/native/arm/vsigned.c b/native/arm/vsigned.c new file mode 100644 index 000000000..fc2537662 --- /dev/null +++ b/native/arm/vsigned.c @@ -0,0 +1,6 @@ +#include "scanning.h" + +void vsigned(const GoString *src, long *p, JsonState *ret) { + int64_t sgn = 1; + vinteger(int64_t, sgn, sgn = -1); +} diff --git a/native/arm/vstring.c b/native/arm/vstring.c new file mode 100644 index 000000000..94e9d8aa2 --- /dev/null +++ b/native/arm/vstring.c @@ -0,0 +1,5 @@ +#include "vstring.h" + +void vstring(const GoString *src, long *p, JsonState *ret, uint64_t flags) { + return vstring_1(src, p, ret, flags); +} diff --git a/native/arm/vstring.h b/native/arm/vstring.h new file mode 100644 index 000000000..b40fd4e3a --- /dev/null +++ b/native/arm/vstring.h @@ -0,0 +1,23 @@ + +#pragma once + +#include "scanning.h" + +static INLINE_FOR_ARM void vstring_1(const GoString *src, long *p, JsonState *ret, uint64_t flags) { + int64_t v = -1; + int64_t i = *p; + ssize_t e = advance_string(src, i, &v, flags); + + /* check for errors */ + if (e < 0) { + *p = src->len; + ret->vt = e; + return; + } + + /* update the result, and fix the escape position (escaping past the end of string) */ + *p = e; + ret->iv = i; + ret->vt = V_STRING; + ret->ep = v >= e ? -1 : v; +} diff --git a/native/arm/vunsigned.c b/native/arm/vunsigned.c new file mode 100644 index 000000000..27649681c --- /dev/null +++ b/native/arm/vunsigned.c @@ -0,0 +1,9 @@ +#include "scanning.h" + +void vunsigned(const GoString *src, long *p, JsonState *ret) { + vinteger(uint64_t, 1, { + *p = i - 1; + ret->vt = -ERR_NUMBER_FMT; + return; + }) +} diff --git a/tools/asm2arm/arm.py b/tools/asm2arm/arm.py new file mode 100644 index 000000000..5c8181568 --- /dev/null +++ b/tools/asm2arm/arm.py @@ -0,0 +1,2386 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + +import os +import sys +import string +import argparse +import itertools +import functools + +from typing import Any +from typing import Dict +from typing import List +from typing import Type +from typing import Tuple +from typing import Union +from typing import Callable +from typing import Iterable +from typing import Optional + +import mcasm + +class InstrStreamer(mcasm.Streamer): + data: bytes + instr: Optional[mcasm.mc.Instruction] + fixups: List[mcasm.mc.Fixup] + + def __init__(self): + self.data = b'' + self.instr = None + self.fixups = [] + super().__init__() + + def unhandled_event(self, name: str, base_impl, *args, **kwargs): + if name == 'emit_instruction': + self.instr = args[1] + self.data = args[2] + self.fixups = args[3] + return super().unhandled_event(name, base_impl, *args, **kwargs) + +### Instruction Parser (GAS Syntax) ### +class Token: + tag: int + val: Union[int, str] + + def __init__(self, tag: int, val: Union[int, str]): + self.val = val + self.tag = tag + + @classmethod + def end(cls): + return cls(TOKEN_END, '') + + @classmethod + def reg(cls, reg: str): + return cls(TOKEN_REG, reg) + + @classmethod + def imm(cls, imm: int): + return cls(TOKEN_IMM, imm) + + @classmethod + def num(cls, num: int): + return cls(TOKEN_NUM, num) + + @classmethod + def name(cls, name: str): + return cls(TOKEN_NAME, name) + + @classmethod + def punc(cls, punc: str): + return cls(TOKEN_PUNC, punc) + + def __repr__(self): + if self.tag == TOKEN_END: + return '' + elif self.tag == TOKEN_REG: + return '' % self.val + elif self.tag == TOKEN_IMM: + return '' % self.val + elif self.tag == TOKEN_NUM: + return '' % self.val + elif self.tag == TOKEN_NAME: + return '' % repr(self.val) + elif self.tag == TOKEN_PUNC: + return '' % repr(self.val) + else: + return '' % (self.tag, self.val) + +class Label: + name: str + offs: Optional[int] + + def __init__(self, name: str): + self.name = name + self.offs = None + + def __str__(self): + return self.name + + def __repr__(self): + if self.offs is None: + return '{LABEL %s (unresolved)}' % self.name + else: + return '{LABEL %s (offset: %d)}' % (self.name, self.offs) + + def resolve(self, offs: int): + self.offs = offs + +class Index: + base : 'Register' + scale : int + + def __init__(self, base: 'Register', scale: int = 1): + self.base = base + self.scale = scale + + def __str__(self): + if self.scale == 1: + return ',%s' % self.base + elif self.scale >= 2: + return ',%s,%d' % (self.base, self.scale) + else: + raise RuntimeError('invalid parser state: invalid scale') + + def __repr__(self): + if self.scale == 1: + return repr(self.base) + elif self.scale >= 2: + return '%d * %r' % (self.scale, self.base) + else: + raise RuntimeError('invalid parser state: invalid scale') + +class Memory: + base : Optional['Register'] + disp : Optional['Displacement'] + index : Optional[Index] + + def __init__(self, base: Optional['Register'], disp: Optional['Displacement'], index: Optional[Index]): + self.base = base + self.disp = disp + self.index = index + self._validate() + + def __str__(self): + return '%s(%s%s)' % ( + '' if self.disp is None else self.disp, + '' if self.base is None else self.base, + '' if self.index is None else self.index + ) + + def __repr__(self): + return '{MEM %r%s%s}' % ( + '' if self.base is None else self.base, + '' if self.index is None else ' + ' + repr(self.index), + '' if self.disp is None else ' + ' + repr(self.disp) + ) + + def _validate(self): + if self.base is None and self.index is None: + raise SyntaxError('either base or index must be specified') + +class Register: + reg: str + + def __init__(self, reg: str): + self.reg = reg.lower() + + def __str__(self): + return '%' + self.reg + + def __repr__(self): + return '{REG %s}' % self.reg + +class Immediate: + val: int + ref: str + + def __init__(self, val: int): + self.ref = '' + self.val = val + + def __str__(self): + return '$%d' % self.val + + def __repr__(self): + return '{IMM bin:%s, oct:%s, dec:%d, hex:%s}' % ( + bin(self.val)[2:], + oct(self.val)[2:], + self.val, + hex(self.val)[2:], + ) + +class Reference: + ref: str + disp: int + off: Optional[int] + + def __init__(self, ref: str, disp: int = 0): + self.ref = ref + self.disp = disp + self.off = None + + def __str__(self): + if self.off is None: + return self.ref + else: + return '$' + str(self.off) + + def __repr__(self): + if self.off is None: + return '{REF %s + %d (unresolved)}' % (self.ref, self.disp) + else: + return '{REF %s + %d (offset: %d)}' % (self.ref, self.disp, self.off) + + @property + def offset(self) -> int: + if self.off is None: + raise SyntaxError('unresolved reference to ' + repr(self.ref)) + else: + return self.off + + def resolve(self, off: int): + self.off = self.disp + off + +Operand = Union[ + Label, + Memory, + Register, + Immediate, + Reference, +] + +Displacement = Union[ + Immediate, + Reference, +] + +TOKEN_END = 0 +TOKEN_REG = 1 +TOKEN_IMM = 2 +TOKEN_NUM = 3 +TOKEN_NAME = 4 +TOKEN_PUNC = 5 + +ARM_ADRP_IMM_BIT_SIZE = 21 +ARM_ADR_WIDTH = 1024 * 1024 + +class Instruction: + comments: str + mnemonic: str + asm_code: str + data: bytes + instr: Optional[mcasm.mc.Instruction] + fixups: List[mcasm.mc.Fixup] + offs_: Optional[int] + ADRP_label: Optional[str] + text_label: Optional[str] + back_label: Optional[str] + ADR_instr: Optional[str] + adrp_asm: Optional[str] + is_adrp: bool + + def __init__(self, line: str, adrp_count=0): + self.comments = '' + self.offs_ = None + self.is_adrp = False + self.asm = mcasm.Assembler('aarch64-apple-macos11') + + self.parse(line, adrp_count) + + def __str__(self): + return self.asm_code + + def __repr__(self): + return '{INSTR %s}' % ( self.asm_code ) + + @property + def jmptab(self) -> Optional[str]: + if self.is_adrp and self.label_name.find(CLANG_JUMPTABLE_LABLE) != -1: + return self.label_name + + @property + def size(self) -> int: + return len(self.data) + + @functools.cached_property + def label_name(self) -> Optional[str]: + if len(self.fixups) > 1: + raise RuntimeError('has more than 1 fixup: ' + self.asm_code) + if self.need_reloc: + if self.mnemonic == 'adr': + return self.fixups[0].value.sub_expr.symbol.name + else: + return self.fixups[0].value.symbol.name + else: + return None + + @functools.cached_property + def is_branch(self) -> bool: + return self.instr.desc.is_branch or self.is_invoke + + @functools.cached_property + def is_return(self) -> bool: + return self.instr.desc.is_return + + @functools.cached_property + def is_jmpq(self) -> bool: + # return self.mnemonic == 'br' + return False + + @functools.cached_property + def is_jmp(self) -> bool: + return self.mnemonic == 'b' + + @functools.cached_property + def is_invoke(self) -> bool: + return self.instr.desc.is_call + + @property + def is_branch_label(self) -> bool: + return self.is_branch and (len(self.fixups) != 0) + + @property + def need_reloc(self) -> bool: + return (len(self.fixups) != 0) + + def set_label_offset(self, off): + # arm64 + self.offs_ = off + 4 + + # def _encode_normal_instr(self) -> str: + # return self.encode(self.data, self.asm_code) + + @functools.cached_property + def encoded(self) -> str: + if self.need_reloc: + return self._encode_reloc_instr() + else: + return self._encode_normal_instr() + + def _check_offs_is_valid(self, bit_size: int): + if abs(self.offs_) > (1 << bit_size): + raise RuntimeError('offset is too larger, [assembly]: %s, [offset]: %d, [valid off size]: %d' + % (self.asm_code, self.offs_, self.fixups[0].kind_info.bit_size)) + + def _encode_adr(self): + buf = int.from_bytes(self.data, byteorder='little') + bit_size = ARM_ADRP_IMM_BIT_SIZE + + self._check_offs_is_valid(bit_size) + + # adrp op: | op | immlo | 1 0 0 0 0 | immhi | Rd | + # |31 |30 29|28 24|23 5|4 0| + imm_lo = (self.offs_ << 29) & 0x60000000 + imm_hi = (self.offs_ << 3) & 0x00FFFFE0 + encode_data = (buf + imm_lo + imm_hi).to_bytes(4, byteorder='little') + self.data = encode_data + # return self.encode(encode_data, '%s $%s(%%rip)' % (str(self), self.offs_)) + + def _encode_rel32(self): + if self.mnemonic == 'adrp' or self.mnemonic == 'adr': + return self._encode_adr() + buf = int.from_bytes(self.data, byteorder='little') + + imm = self.offs_ + imm_size = self.fixups[0].kind_info.bit_size + imm_offset = self.fixups[0].kind_info.bit_offset + if self.fixups[0].kind_info.is_pc_rel == 1: + # except adr and adrp, other PC-releative instructions need times 4 + imm = imm >> 2 + # immediate bit size has 1-bit for sign + self._check_offs_is_valid(imm_size - 1 + 2) + else: + self._check_offs_is_valid(imm_size) + + imm = imm << imm_offset + mask = (0x1 << (imm_size + imm_offset)) - 1 + buf = buf | (imm & mask) + buf = buf.to_bytes(4, byteorder='little') + self.data = buf + # return self.encode(buf, '%s $%s(%%rip)' % (str(self), self.offs_)) + + def _encode_page(self): + if self.mnemonic != 'adrp': + raise RuntimeError("not adrp instruction: %s" % self.asm_code) + self.offs_ = self.offs_ >> 12 + return self._encode_rel32() + + def _encode_pageoff(self): + self.offs_ = 0 + return self._encode_rel32() + + def _fixup_rel32(self): + if self.offs_ is None: + raise RuntimeError('unresolved label %s' % self.label_name) + + if self.mnemonic == 'adr': + self._encode_adr() + elif self.fixups[0].value.variant_kind == mcasm.mc.SymbolRefExpr.VariantKind.PAGEOFF: + self._encode_pageoff() + elif self.fixups[0].value.variant_kind == mcasm.mc.SymbolRefExpr.VariantKind.PAGE: + self._encode_page() + else: + self._encode_rel32() + + def _encode_reloc_instr(self) -> str: + self._fixup_rel32() + return self.encode(self.data, '%s $%s(%%rip)' % (str(self), self.offs_)) + + def _encode_normal_instr(self) -> str: + return self.encode(self.data, str(self)) + + def _raw_instr(self) -> bytes: + if self.need_reloc: + self._fixup_rel32() + return self.data + + def _fixup_adrp(self, line: str, adrp_count: int) -> str: + reg = line.split()[1].split(',')[0] + self.text_label = line.split()[2].split('@')[0] + self.ADRP_label = self.text_label + '_' + reg + '_' + str(adrp_count) + self.back_label = '_back_adrp_' + str(adrp_count) + self.ADR_instr = 'adr ' + reg + ', ' + self.text_label + self.adrp_asm = line + self.is_adrp = True + line = 'b ' + self.ADRP_label + self.asm_code = line + ' // ' + self.adrp_asm + + return line + + def _parse_by_mcasm(self, line: str): + streamer = InstrStreamer() + # self.asm.assemble(streamer, line, MCPU="", features_str="") + self.asm.assemble(streamer, line) + if streamer.instr is None: + raise RuntimeError('cannot parse assembly: %s' % line) + self.instr = streamer.instr + + # instead of short jump instruction + self.data = streamer.data + + self.fixups = streamer.fixups + self.mnemonic = line.split()[0] + + def convert_to_adr(self): + self.is_adrp = True + adr_asm = self.adrp_asm.replace('adrp', 'adr') + self.asm_code = adr_asm + ' // ' + self.adrp_asm + # self._parse_by_mcasm(adr_asm) + return self.asm_code + + def parse(self, line: str, adrp_count: int): + # machine code + menmonic = line.split()[0] + + self.ADRP_label = None + self.text_label = None + # turn adrp to jmp + if (menmonic == 'adrp'): + line = self.convert_to_adr() + else: + self.asm_code = line + + self._parse_by_mcasm(line) + + @staticmethod + def encode(buf: bytes, comments: str = '') -> str: + i = 0 + r = [] + n = len(buf) + + # @debug + # while i < n - 3: + # r.append('%08x' % int.from_bytes(buf[i:i + 4], 'little')) + # i += 4 + # return '\n\t'.join(r) + + if (n % 4 != 0): + raise RuntimeError("Unkown instruction which not encoding 4 bytes: %s " % comments, buf) + + while i < n - 3: + r.append('WORD $0x%08x' % int.from_bytes(buf[i:i + 4], 'little')) + i += 4 + + # join them together, and attach the comment if any + if not comments: + return '; '.join(r) + else: + return '%s // %s' % ('; '.join(r), comments) + + Reg = Optional[Register] + Disp = Optional[Displacement] + +### Prototype Parser ### + +ARGS_ORDER_C = [ + Register('x0'), + Register('x1'), + Register('x2'), + Register('x3'), + Register('x4'), + Register('x5'), + Register('x6'), + Register('x7'), +] + +ARGS_ORDER_GO = [ + Register('R0'), + Register('R1'), + Register('R2'), + Register('R3'), + Register('R4'), + Register('R5'), + Register('R6'), + Register('R7'), +] + +FPARGS_ORDER = [ + Register('D0'), + Register('D1'), + Register('D2'), + Register('D3'), + Register('D4'), + Register('D5'), + Register('D6'), + Register('D7'), +] + +class Parameter: + name : str + size : int + creg : Register + goreg: Register + + def __init__(self, name: str, size: int, reg: Register, goreg: Register): + self.creg = reg + self.goreg = reg + self.name = name + self.size = size + + def __repr__(self): + return '' % (self.name, self.size, self.creg) + +class Pcsp: + entry: int + maxpc: int + out : List[Tuple[int, int]] + pc : int + sp : int + + def __init__(self, entry: int): + self.out = [] + self.maxpc = entry + self.entry = entry + self.pc = entry + self.sp = 0 + + def __str__(self) -> str: + ret = '[][2]uint32{\n' + for pc, sp in self.out: + ret += ' {%d, %d},\n' % (pc, sp) + return ret + ' }' + + def optimize(self): + # push the last record + self.out.append((self.pc - self.entry, self.sp)) + # sort by pc + self.out.sort(key=lambda x: x[0]) + # NOTICE: first pair {1, 0} to be compitable with golang + tmp = [(1, 0)] + lpc, lsp = 0, -1 + for pc, sp in self.out: + # sp changed, push new record + if pc != lpc and sp != lsp: + tmp.append((pc, sp)) + # sp unchanged, replace with the higher pc + if pc != lpc and sp == lsp: + if len(tmp) > 0: + tmp.pop(-1) + tmp.append((pc, sp)) + + lpc, lsp = pc, sp + self.out = tmp + + def update(self, dpc: int, dsp: int): + self.out.append((self.pc - self.entry, self.sp)) + self.pc += dpc + self.sp += dsp + if self.pc > self.maxpc: + self.maxpc = self.pc + +class Prototype: + args: List[Parameter] + retv: Optional[Parameter] + + def __init__(self, retv: Optional[Parameter], args: List[Parameter]): + self.retv = retv + self.args = args + + def __repr__(self): + if self.retv is None: + return '' % repr(self.args) + else: + return ' %r>' % (self.args, self.retv) + + @property + def argspace(self) -> int: + return sum( + [v.size for v in self.args], + (0 if self.retv is None else self.retv.size) + ) + +class PrototypeMap(Dict[str, Prototype]): + @staticmethod + def _dv(c: str) -> int: + if c == '(': + return 1 + elif c == ')': + return -1 + else: + return 0 + + @staticmethod + def _tk(s: str, p: str) -> bool: + return s.startswith(p) and (s == p or s[len(p)].isspace()) + + @classmethod + def _punc(cls, s: str) -> bool: + return s in cls.__puncs_ + + @staticmethod + def _err(msg: str) -> SyntaxError: + return SyntaxError( + msg + ', ' + + 'the parser integrated in this tool is just a text-based parser, ' + + 'so please keep the companion .go file as simple as possible and do not use defined types' + ) + + @staticmethod + def _align(nb: int) -> int: + return (((nb - 1) >> 3) + 1) << 3 + + @classmethod + def _retv(cls, ret: str) -> Tuple[str, int, Register, Register]: + name, size, xmm = cls._args(ret) + reg = Register('d0') if xmm else Register('x0') + return name, size, reg, reg + + @classmethod + def _args(cls, arg: str, sv: str = '') -> Tuple[str, int, bool]: + while True: + if not arg: + raise SyntaxError('missing type for parameter: ' + sv) + elif arg[0] != '_' and not arg[0].isalnum(): + return (sv,) + cls._size(arg.strip()) + elif not sv and arg[0].isdigit(): + raise SyntaxError('invalid character: ' + repr(arg[0])) + else: + sv += arg[0] + arg = arg[1:] + + @classmethod + def _size(cls, name: str) -> Tuple[int, bool]: + if name[0] == '*': + return cls._align(8), False + elif name in ('int8', 'uint8', 'byte', 'bool'): + return cls._align(1), False + elif name in ('int16', 'uint16'): + return cls._align(2), False + elif name == 'float32': + return cls._align(4), True + elif name in ('int32', 'uint32', 'rune'): + return cls._align(4), False + elif name == 'float64': + return cls._align(8), True + elif name in ('int64', 'uint64', 'uintptr', 'int', 'Pointer', 'unsafe.Pointer'): + return cls._align(8), False + else: + raise cls._err('unrecognized type "%s"' % name) + + @classmethod + def _func(cls, src: List[str], idx: int, depth: int = 0) -> Tuple[str, int]: + for i in range(idx, len(src)): + for x in map(cls._dv, src[i]): + if depth + x >= 0: + depth += x + else: + raise cls._err('encountered ")" more than "(" on line %d' % (i + 1)) + else: + if depth == 0: + return ' '.join(src[idx:i + 1]), i + 1 + else: + raise cls._err('unexpected EOF when parsing function signatures') + + @classmethod + def parse(cls, src: str) -> Tuple[str, 'PrototypeMap']: + idx = 0 + pkg = '' + ret = PrototypeMap() + buf = src.splitlines() + + # scan through all the lines + while idx < len(buf): + line = buf[idx] + line = line.strip() + + # skip empty lines + if not line: + idx += 1 + continue + + # check for package name + if cls._tk(line, 'package'): + idx, pkg = idx + 1, line[7:].strip().split()[0] + continue + + if OUTPUT_RAW: + + # extract funcname like "[var ]{funcname} = func(..." + end = line.find('func(') + if end == -1: + idx += 1 + continue + name = line[:end].strip() + if name.startswith('var '): + name = name[4:].strip() + + # function names must be identifiers + if not name.isidentifier(): + raise cls._err('invalid function prototype: ' + name) + + # register a empty prototype + ret[name] = Prototype(None, []) + idx += 1 + + else: + + # only cares about those functions that does not have bodies + if line[-1] == '{' or not cls._tk(line, 'func'): + idx += 1 + continue + + # prevent type-aliasing primitive types into other names + if cls._tk(line, 'type'): + raise cls._err('please do not declare any type with in the companion .go file') + + # find the next function declaration + decl, pos = cls._func(buf, idx) + func, idx = decl[4:].strip(), pos + + # find the beginning '(' + nd = 1 + pos = func.find('(') + + # must have a '(' + if pos == -1: + raise cls._err('invalid function prototype: ' + decl) + + # extract the name and signature + args = '' + name = func[:pos].strip() + func = func[pos + 1:].strip() + + # skip the method declaration + if not name: + continue + + # function names must be identifiers + if not name.isidentifier(): + raise cls._err('invalid function prototype: ' + decl) + + # extract the argument list + while nd and func: + nch = func[0] + func = func[1:] + + # adjust the nesting level + nd += cls._dv(nch) + args += nch + + # check for EOF + if not nd: + func = func.strip() + else: + raise cls._err('unexpected EOF when parsing function prototype: ' + decl) + + # check for multiple returns + if ',' in func: + raise cls._err('can only return a single value (detected by looking for "," within the return list)') + + # check for return signature + if not func: + retv = None + elif func[0] == '(' and func[-1] == ')': + retv = Parameter(*cls._retv(func[1:-1])) + else: + raise SyntaxError('badly formatted return argument (please use parenthesis and proper arguments naming): ' + func) + + # extract the argument list + if not args[:-1]: + args, alens, axmm = [], [], [] + else: + args, alens, axmm = list(zip(*[cls._args(v.strip()) for v in args[:-1].split(',')])) + + # check for the result + cregs = [] + goregs = [] + idxs = [0, 0] + + # split the integer & floating point registers + for xmm in axmm: + key = 0 if xmm else 1 + seq = FPARGS_ORDER if xmm else ARGS_ORDER_C + goseq = FPARGS_ORDER if xmm else ARGS_ORDER_GO + + # check the argument count + if idxs[key] >= len(seq): + raise cls._err("too many arguments, consider pack some into a pointer") + + # add the register + cregs.append(seq[idxs[key]]) + goregs.append(goseq[idxs[key]]) + idxs[key] += 1 + + # register the prototype + ret[name] = Prototype(retv, [ + Parameter(arg, size, creg, goreg) + for arg, size, creg, goreg in zip(args, alens, cregs, goregs) + ]) + + # all done + return pkg, ret + +### Assembly Source Parser ### + +ESC_IDLE = 0 # escape parser is idleing +ESC_ISTR = 1 # currently inside a string +ESC_BKSL = 2 # encountered backslash, prepare for escape sequences +ESC_HEX0 = 3 # expect the first hexadecimal character of a "\x" escape +ESC_HEX1 = 4 # expect the second hexadecimal character of a "\x" escape +ESC_OCT1 = 5 # expect the second octal character of a "\000" escape +ESC_OCT2 = 6 # expect the third octal character of a "\000" escape + +class Command: + cmd : str + args : List[Union[str, bytes]] + + def __init__(self, cmd: str, args: List[Union[str, bytes]]): + self.cmd = cmd + self.args = args + + def __repr__(self): + return '' % (self.cmd, ', '.join(map(repr, self.args))) + + @classmethod + def parse(cls, src: str) -> 'Command': + val = src.split(None, 1) + cmd = val[0] + + # no parameters + if len(val) == 1: + return cls(cmd, []) + + # extract the argument string + idx = 0 + esc = 0 + pos = None + args = [] + vstr = val[1] + + # scan through the whole string + while idx < len(vstr): + nch = vstr[idx] + idx += 1 + + # mark the start of the argument + if pos is None: + pos = idx - 1 + + # encountered the delimiter outside of a string + if nch == ',' and esc == ESC_IDLE: + pos, p = None, pos + args.append(vstr[p:idx - 1].strip()) + + # start of a string + elif nch == '"' and esc == ESC_IDLE: + esc = ESC_ISTR + + # end of string + elif nch == '"' and esc == ESC_ISTR: + esc = ESC_IDLE + pos, p = None, pos + args.append(vstr[p:idx].strip()[1:-1].encode('utf-8').decode('unicode_escape')) + + # escape characters + elif nch == '\\' and esc == ESC_ISTR: + esc = ESC_BKSL + + # hexadecimal escape characters (3 chars) + elif esc == ESC_BKSL and nch == 'x': + esc = ESC_HEX0 + + # octal escape characters (3 chars) + elif esc == ESC_BKSL and nch in string.octdigits: + esc = ESC_OCT1 + + # generic escape characters (single char) + elif esc == ESC_BKSL and nch in ('a', 'b', 'f', 'r', 'n', 't', 'v', '"', '\\'): + esc = ESC_ISTR + + # invalid escape sequence + elif esc == ESC_BKSL: + raise SyntaxError('invalid escape character: ' + repr(nch)) + + # normal characters, simply advance to the next character + elif esc in (ESC_IDLE, ESC_ISTR): + pass + + # hexadecimal escape characters + elif esc in (ESC_HEX0, ESC_HEX1) and nch.lower() in string.hexdigits: + esc = ESC_HEX1 if esc == ESC_HEX0 else ESC_ISTR + + # invalid hexadecimal character + elif esc in (ESC_HEX0, ESC_HEX1): + raise SyntaxError('invalid hexdecimal character: ' + repr(nch)) + + # octal escape characters + elif esc in (ESC_OCT1, ESC_OCT2) and nch.lower() in string.octdigits: + esc = ESC_OCT2 if esc == ESC_OCT1 else ESC_ISTR + + # at most 3 octal digits + elif esc in (ESC_OCT1, ESC_OCT2): + esc = ESC_ISTR + + # illegal state, should not happen + else: + raise RuntimeError('illegal state: %d' % esc) + + # check for the last argument + if pos is None: + return cls(cmd, args) + + # add the last argument and build the command + args.append(vstr[pos:].strip()) + return cls(cmd, args) + +class Expression: + pos: int + src: str + + def __init__(self, src: str): + self.pos = 0 + self.src = src + + @property + def _ch(self) -> str: + return self.src[self.pos] + + @property + def _eof(self) -> bool: + return self.pos >= len(self.src) + + def _rch(self) -> str: + pos, self.pos = self.pos, self.pos + 1 + return self.src[pos] + + def _hex(self, ch: str) -> bool: + if len(ch) == 1 and ch[0] == '0': + return self._ch.lower() == 'x' + elif len(ch) <= 1 or ch[1].lower() != 'x': + return self._ch.isdigit() + else: + return self._ch in string.hexdigits + + def _int(self, ch: str) -> Token: + while not self._eof and self._hex(ch): + ch += self._rch() + else: + if ch.lower().startswith('0x'): + return Token.num(int(ch, 16)) + elif ch[0] == '0': + return Token.num(int(ch, 8)) + else: + return Token.num(int(ch)) + + def _name(self, ch: str) -> Token: + while not self._eof and (self._ch == '_' or self._ch.isalnum()): + ch += self._rch() + else: + return Token.name(ch) + + def _read(self, ch: str) -> Token: + if ch.isdigit(): + return self._int(ch) + elif ch.isidentifier(): + return self._name(ch) + elif ch in ('*', '<', '>') and not self._eof and self._ch == ch: + return Token.punc(self._rch() * 2) + elif ch in ('+', '-', '*', '/', '%', '&', '|', '^', '~', '(', ')'): + return Token.punc(ch) + else: + raise SyntaxError('invalid character: ' + repr(ch)) + + def _peek(self) -> Optional[Token]: + pos = self.pos + ret = self._next() + self.pos = pos + return ret + + def _next(self) -> Optional[Token]: + while not self._eof and self._ch.isspace(): + self.pos += 1 + else: + return Token.end() if self._eof else self._read(self._rch()) + + def _grab(self, tk: Token, getvalue: Callable[[str], int]) -> int: + if tk.tag == TOKEN_NUM: + return tk.val + elif tk.tag == TOKEN_NAME: + return getvalue(tk.val) + else: + raise SyntaxError('integer or identifier expected, got ' + repr(tk)) + + __pred__ = [ + {'<<', '>>'}, + {'|'}, + {'^'}, + {'&'}, + {'+', '-'}, + {'*', '/', '%'}, + {'**'}, + ] + + __binary__ = { + '+' : lambda a, b: a + b, + '-' : lambda a, b: a - b, + '*' : lambda a, b: a * b, + '/' : lambda a, b: a / b, + '%' : lambda a, b: a % b, + '&' : lambda a, b: a & b, + '^' : lambda a, b: a ^ b, + '|' : lambda a, b: a | b, + '<<' : lambda a, b: a << b, + '>>' : lambda a, b: a >> b, + '**' : lambda a, b: a ** b, + } + + def _eval(self, op: str, v1: int, v2: int) -> int: + return self.__binary__[op](v1, v2) + + def _nest(self, nest: int, getvalue: Callable[[str], int]) -> int: + ret = self._expr(0, nest + 1, getvalue) + ntk = self._next() + + # it must follows with a ')' operator + if ntk.tag != TOKEN_PUNC or ntk.val != ')': + raise SyntaxError('")" expected, got ' + repr(ntk)) + else: + return ret + + def _unit(self, nest: int, getvalue: Callable[[str], int]) -> int: + tk = self._next() + tt, tv = tk.tag, tk.val + + # check for unary operators + if tt == TOKEN_NUM: + return tv + elif tt == TOKEN_NAME: + return getvalue(tv) + elif tt == TOKEN_PUNC and tv == '(': + return self._nest(nest, getvalue) + elif tt == TOKEN_PUNC and tv == '+': + return self._unit(nest, getvalue) + elif tt == TOKEN_PUNC and tv == '-': + return -self._unit(nest, getvalue) + elif tt == TOKEN_PUNC and tv == '~': + return ~self._unit(nest, getvalue) + else: + raise SyntaxError('integer, unary operator or nested expression expected, got ' + repr(tk)) + + def _term(self, pred: int, nest: int, getvalue: Callable[[str], int]) -> int: + lv = self._expr(pred + 1, nest, getvalue) + tk = self._peek() + + # scan to the end + while True: + tt = tk.tag + tv = tk.val + + # encountered EOF + if tt == TOKEN_END: + return lv + + # must be an operator here + if tt != TOKEN_PUNC: + raise SyntaxError('operator expected, got ' + repr(tk)) + + # check for the operator precedence + if tv not in self.__pred__[pred]: + return lv + + # apply the operator + op = self._next().val + rv = self._expr(pred + 1, nest, getvalue) + lv = self._eval(op, lv, rv) + tk = self._peek() + + def _expr(self, pred: int, nest: int, getvalue: Callable[[str], int]) -> int: + if pred >= len(self.__pred__): + return self._unit(nest, getvalue) + else: + return self._term(pred, nest, getvalue) + + def eval(self, getvalue: Callable[[str], int]) -> int: + return self._expr(0, 0, getvalue) + + +class Instr: + ALIGN_WIDTH = 48 + len : int = NotImplemented + instr : Union[str, Instruction] = NotImplemented + + def size(self, _: int) -> int: + return self.len + + def formatted(self, pc: int) -> str: + raise NotImplementedError + + @staticmethod + def raw_formatted(bs: bytes, comm: str, pc: int) -> str: + t = '\t' + if bs: + for b in bs: + t +='0x%02x, ' % b + # if len(bs) str: + return '\t' + self.instr + + def raw_formatted(self, pc: int) -> str: + return Instr.raw_formatted(self.bs, self.instr, pc) + +class IntInstr(Instr): + comm: str + func: Callable[[], int] + + def __init__(self, size: int, func: Callable[[], int], comments: str = ''): + self.len = size + self.func = func + self.comm = comments + + @property + def raw_bytes(self): + return self.func().to_bytes(self.len, 'little') + + @property + def instr(self) -> str: + return Instruction.encode(self.func().to_bytes(self.len, 'little'), self.comm) + + def formatted(self, _: int) -> str: + return '\t' + self.instr + + def raw_formatted(self, pc: int) -> str: + return Instr.raw_formatted(self.func().to_bytes(self.len, 'little'), self.comm, pc) + +class X86Instr(Instr): + def __init__(self, instr: Instruction): + self.len = instr.size + self.instr = instr + + def resize(self, size: int) -> int: + self.len = size + return size + + def formatted(self, _: int) -> str: + return '\t' + self.instr.encoded + + def raw_formatted(self, pc: int) -> str: + return Instr.raw_formatted(self.instr._raw_instr(), str(self.instr), pc) + +class LabelInstr(Instr): + def __init__(self, name: str): + self.len = 0 + self.instr = name + + def formatted(self, _: int) -> str: + if self.instr.isidentifier(): + return self.instr + ':' + else: + return '_LB_%08x: // %s' % (hash(self.instr) & 0xffffffff, self.instr) + + def raw_formatted(self, pc: int) -> str: + return Instr.raw_formatted(None, str(self.instr), pc) + +class BranchInstr(Instr): + def __init__(self, instr: Instruction): + self.len = instr.size + self.instr = instr + + def formatted(self, _: int) -> str: + return '\t' + self.instr.encoded + + def raw_formatted(self, pc: int) -> str: + return Instr.raw_formatted(self.instr._raw_instr(), str(self.instr), pc) + +class CommentInstr(Instr): + def __init__(self, text: str): + self.len = 0 + self.instr = '// ' + text + + def formatted(self, _: int) -> str: + return '\t' + self.instr + + def raw_formatted(self, pc: int) -> str: + return Instr.raw_formatted(None, str(self.instr), None) + +class AlignmentInstr(Instr): + bits: int + fill: int + + def __init__(self, bits: int, fill: int = 0): + self.bits = bits + self.fill = fill + + def size(self, pc: int) -> int: + mask = (1 << self.bits) - 1 + return (mask - (pc & mask) + 1) & mask + + def formatted(self, pc: int) -> str: + buf = bytes([self.fill]) * self.size(pc) + return '\t' + Instruction.encode(buf, '.p2align %d, 0x%02x' % (self.bits, self.fill)) + + def raw_formatted(self, pc: int) -> str: + buf = bytes([self.fill]) * self.size(pc) + return Instr.raw_formatted(buf, '.p2align %d, 0x%02x' % (self.bits, self.fill), pc) + +REG_MAP = { + 'x0' : ('MOVD' , 'R0'), + 'x1' : ('MOVD' , 'R1'), + 'x2' : ('MOVD' , 'R2'), + 'x3' : ('MOVD' , 'R3'), + 'x4' : ('MOVD' , 'R4'), + 'x5' : ('MOVD' , 'R5'), + 'x6' : ('MOVD' , 'R6'), + 'x7' : ('MOVD' , 'R7'), + 'd0' : ('FMOVD' , 'F0'), + 'd1' : ('FMOVD' , 'F1'), + 'd2' : ('FMOVD' , 'F2'), + 'd3' : ('FMOVD' , 'F3'), + 'd4' : ('FMOVD' , 'F4'), + 'd5' : ('FMOVD' , 'F5'), + 'd6' : ('FMOVD' , 'F6'), + 'd7' : ('FMOVD' , 'F7'), +} + +class Counter: + value: int = 0 + + @classmethod + def next(cls) -> int: + val, cls.value = cls.value, cls.value + 1 + return val + +class BasicBlock: + maxsp: int + name: str + weak: bool + jmptab: bool + func: bool + body: List[Instr] + prevs: List['BasicBlock'] + next: Optional['BasicBlock'] + jump: Optional['BasicBlock'] + + def __init__(self, name: str, weak: bool = True, jmptab: bool = False, func: bool = False): + self.maxsp = -1 + self.body = [] + self.prevs = [] + self.name = name + self.weak = weak + self.next = None + self.jump = None + self.jmptab = jmptab + self.func = func + + def __repr__(self): + return '{BasicBlock %s}' % repr(self.name) + + @property + def last(self) -> Optional[Instr]: + return next((v for v in reversed(self.body) if not isinstance(v, CommentInstr)), None) + + def if_all_IntInstr_then_2_RawInstr(self): + is_table = False + instr_size = 0 + for instr in self.body: + if isinstance(instr, IntInstr): + if not is_table: + instr_size = instr.len + is_table = True + if instr_size != instr.len: + instr_size = 0 + continue + if isinstance(instr, AlignmentInstr): + continue + if isinstance(instr, LabelInstr): + continue + # others + return + + if not is_table: + return + + # .long or .quad + if instr_size == 8 or instr_size == 4: + return + + # All instrs are IntInstr, golang asm only suuport WORD and DWORD for arm. We need + # combine them as 4-bytes RawInstr and align block + nb = [] # new body + raw_buf = []; + comment = '' + + # first element is LabelInstr + for i in range(1, len(self.body)): + if isinstance(self.body[i], AlignmentInstr): + if i != len(self.body) -1: + raise RuntimeError("Not support p2algin in : %s" % self.name) + continue + + raw_buf += self.body[i].raw_bytes + comment += '// ' + self.body[i].comm + '\n' + + align_size = len(raw_buf) % 4 + if align_size != 0: + raw_buf += int(0).to_bytes(4 - align_size, 'little') + + if isinstance(self.body[0], LabelInstr): + nb.append(self.body[0]) + + for i in range(0, len(raw_buf), 4): + buf = raw_buf[i: i + 4] + nb.append(RawInstr(len(buf), Instruction.encode(buf), buf)) + + nb.append(CommentInstr(comment)) + + if isinstance(self.body[-1:-1], AlignmentInstr): + nb.append(self.body[-1:-1]) + self.body = nb + + def size_of(self, pc: int) -> int: + return functools.reduce(lambda p, v: p + v.size(pc + p), self.body, 0) + + def link_to(self, block: 'BasicBlock'): + self.next = block + block.prevs.append(self) + + def jump_to(self, block: 'BasicBlock'): + self.jump = block + block.prevs.append(self) + + @classmethod + def annonymous(cls) -> 'BasicBlock': + return cls('// bb.%d' % Counter.next(), weak = False) + +CLANG_JUMPTABLE_LABLE = 'LJTI' + +class CodeSection: + dead : bool + export : bool + blocks : List[BasicBlock] + labels : Dict[str, BasicBlock] + jmptabs: Dict[str, List[BasicBlock]] + funcs : Dict[str, Pcsp] + bsmap_ : Dict[str, int] + + def __init__(self): + self.dead = False + self.labels = {} + self.export = False + self.blocks = [BasicBlock.annonymous()] + self.jmptabs = {} + self.funcs = {} + self.bsmap_ = {} + + @classmethod + def _dfs_jump_first(cls, bb: BasicBlock, visited: Dict[BasicBlock, bool], hook: Callable[[BasicBlock], bool]) -> bool: + if bb not in visited or not visited[bb]: + visited[bb] = True + if bb.jump and not cls._dfs_jump_first(bb.jump, visited, hook): + return False + if bb.next and not cls._dfs_jump_first(bb.next, visited, hook): + return False + return hook(bb) + else: + return True + + def get_jmptab(self, name: str) -> List[BasicBlock]: + return self.jmptabs.setdefault(name, []) + + def get_block(self, name: str) -> BasicBlock: + for block in self.blocks: + if block.name == name: + return block + + @property + def block(self) -> BasicBlock: + return self.blocks[-1] + + @property + def instrs(self) -> Iterable[Instr]: + for block in self.blocks: + yield from block.body + + def _make(self, name: str, jmptab: bool = False, func: bool = False): + if func: + #NOTICE: if it is a function, always set func to be True + if (old := self.labels.get(name)) and (old.func != func): + old.func = True + return self.labels.setdefault(name, BasicBlock(name, jmptab = jmptab, func = func)) + + def _next(self, link: BasicBlock): + if self.dead: + self.dead = False + else: + self.block.link_to(link) + + def _decl(self, name: str, block: BasicBlock): + block.weak = False + block.body.append(LabelInstr(name)) + self._next(block) + self.blocks.append(block) + + def _kill(self, name: str): + self.dead = True + self.block.link_to(self._make(name)) + + def _split(self, jmp: BasicBlock): + self.jump = True + link = BasicBlock.annonymous() + self.labels[link.name] = link + self.block.link_to(link) + self.block.jump_to(jmp) + self.blocks.append(link) + + @staticmethod + def _mk_align(v: int) -> int: + if v & 15 == 0: + return v + else: + print('* warning: SP is not aligned with 16 bytes.', file = sys.stderr) + return (v + 15) & -16 + + @staticmethod + def _is_spadj(ins: Instruction) -> bool: + return len(ins.instr.operands) == 3 and \ + isinstance(ins.instr.operands[1], mcasm.mc.Register) and \ + isinstance(ins.instr.operands[2], int) and \ + ins.instr.operands[1].name == 'RSP' + + @staticmethod + def _is_spmove(ins: Instruction, i: int) -> bool: + return len(ins.operands) == 2 and \ + isinstance(ins.operands[0], Register) and \ + isinstance(ins.operands[1], Register) and \ + ins.operands[i].reg == 'rsp' + + @staticmethod + def _is_rjump(ins: Optional[Instr]) -> bool: + return isinstance(ins, X86Instr) and ins.instr.is_branch_label + + def _find_label(self, name: str, adjs: Iterable[int], size: int = 0) -> int: + for adj, block in zip(adjs, self.blocks): + if block.name == name: + return size + else: + # find block size from cache + v = self.bsmap_.get(block.name) + if v is not None: + size += v + adj + else: + block_size = block.size_of(size) + size += block_size + adj + self.bsmap_[block.name] = block_size + else: + raise SyntaxError('unresolved reference to name: ' + name) + + def _alloc_instr(self, instr: Instruction): + if not instr.is_branch_label: + self.block.body.append(X86Instr(instr)) + else: + self.block.body.append(BranchInstr(instr)) + + # it seems to not be able to specify stack aligment inside the Go ASM so we + # need to replace the aligned instructions with unaligned one if either of it's + # operand is an RBP relative addressing memory operand + + def _check_align(self, instr: Instruction) -> bool: + # TODO: check + return False + + def _check_split(self, instr: Instruction): + if instr.is_return: + self.dead = True + + elif instr.is_jmpq: # jmpq + # backtrace jump table from current block (BFS) + prevs = [self.block] + visited = set() + while len(prevs) > 0: + curb = prevs.pop() + if curb in visited: + continue + else: + visited.add(curb) + + # backtrace instructions + for ins in reversed(curb.body): + if isinstance(ins, X86Instr) and ins.instr.jmptab: + self._split(self._make(ins.instr.jmptab, jmptab = True)) + return + + if curb.prevs: + prevs.extend(curb.prevs) + + elif instr.is_branch_label: + if instr.is_jmp: + self._kill(instr.label_name) + + elif instr.is_invoke: # call + fname = instr.label_name + self._split(self._make(fname, func = True)) + + else: # jeq, ja, jae ... + self._split(self._make(instr.label_name)) + + def _trace_block(self, bb: BasicBlock, pcsp: Optional[Pcsp]) -> int: + if (pcsp is not None): + if bb.name in self.funcs: + # already traced + pcsp = None + else: + # continue tracing, update the pcsp + # NOTICE: must mark pcsp at block entry because go only calculate delta value + pcsp.pc = self.get(bb.name) + if bb.func or pcsp.pc < pcsp.entry: + # new func + pcsp = Pcsp(pcsp.pc) + self.funcs[bb.name] = pcsp + + if bb.maxsp == -1: + ret = self._trace_nocache(bb, pcsp) + return ret + elif bb.maxsp >= 0: + return bb.maxsp + else: + return 0 + + def _trace_nocache(self, bb: BasicBlock, pcsp: Optional[Pcsp]) -> int: + bb.maxsp = -2 + + # ## FIXME: + # if pcsp is None: + # pcsp = Pcsp(0) + + # make a fake object just for reducing redundant checking + if pcsp: + pc0, sp0 = pcsp.pc, pcsp.sp + + maxsp, term = self._trace_instructions(bb, pcsp) + + # this is a terminating block + if term: + return maxsp + + # don't trace it's next block if it's an unconditional jump + a, b = 0, 0 + if pcsp: + pc, sp = pcsp.pc, pcsp.sp + + if bb.jump: + if bb.jump.jmptab: + cases = self.get_jmptab(bb.jump.name) + for case in cases: + nsp = self._trace_block(case, pcsp) + if pcsp: + pcsp.pc, pcsp.sp = pc, sp + if nsp > a: + a = nsp + else: + a = self._trace_block(bb.jump, pcsp) + if pcsp: + pcsp.pc, pcsp.sp = pc, sp + + if bb.next: + b = self._trace_block(bb.next, pcsp) + + if pcsp: + pcsp.pc, pcsp.sp = pc0, sp0 + + # select the maximum stack depth + bb.maxsp = maxsp + max(a, b) + return bb.maxsp + + def _trace_instructions(self, bb: BasicBlock, pcsp: Pcsp) -> Tuple[int, bool]: + cursp = 0 + maxsp = 0 + close = False + + # scan every instruction + for ins in bb.body: + diff = 0 + + if isinstance(ins, X86Instr): + name = ins.instr.mnemonic + operands = ins.instr.instr.operands + + # check for instructions + if name == 'ret': + close = True + elif isinstance(operands[0], mcasm.mc.Register) and operands[0].name == 'SP': + # print(ins.instr.asm_code) + if name == 'add': + diff = -self._mk_align(operands[2]) + elif name == 'sub': + diff = self._mk_align(operands[2]) + elif name == 'stp': + diff = -self._mk_align(operands[4] * 8) + elif name == 'ldp': + diff = -self._mk_align(operands[4] * 8) + elif name == 'str': + diff = -self._mk_align(operands[3]) + else: + raise RuntimeError("An instruction adjsut sp but bot processed: %s" % ins.instr.asm_code) + + cursp += diff + + # update the max stack depth + if cursp > maxsp: + maxsp = cursp + + # update pcsp + if pcsp: + pcsp.update(ins.size(pcsp.pc), diff) + + # trace successful + return maxsp, close + + def get(self, key: str) -> Optional[int]: + if key not in self.labels: + raise SyntaxError('unresolved reference to name: %s' % key) + else: + return self._find_label(key, itertools.repeat(0, len(self.blocks))) + + def has(self, key: str) -> bool: + return key in self.labels + + def emit(self, buf: bytes, comments: str = ''): + if not self.dead: + self.block.body.append(RawInstr(len(buf), Instruction.encode(buf, comments or buf.hex()), buf)) + + def lazy(self, size: int, func: Callable[[], int], comments: str = ''): + if not self.dead: + self.block.body.append(IntInstr(size, func, comments)) + + def label(self, name: str): + if name not in self.labels or self.labels[name].weak: + self._decl(name, self._make(name)) + else: + raise SyntaxError('duplicated label: ' + name) + + def instr(self, instr: Instruction): + if not self.dead: + if self._check_align(instr): + return + self._alloc_instr(instr) + self._check_split(instr) + + def stacksize(self, name: str) -> int: + if name not in self.labels: + raise SyntaxError('undefined function: ' + name) + else: + return self._trace_block(self.labels[name], None) + + def pcsp(self, name: str, entry: int) -> int: + if name not in self.labels: + raise SyntaxError('undefined function: ' + name) + else: + pcsp = Pcsp(entry) + self.labels[name].func = True + return self._trace_block(self.labels[name], pcsp) + + def debug(self, pos: int, inss: List[Instruction]): + def inject(bb: BasicBlock) -> bool: + if (not bb.func) and (bb.name not in self.funcs): + return True + nonlocal pos + if pos >= len(bb.body): + return + for ins in inss: + bb.body.insert(pos, ins) + pos += 1 + visited = {} + for _, bb in self.labels.items(): + CodeSection._dfs_jump_first(bb, visited, inject) + def debug(self): + for label, bb in self.labels.items(): + print(label) + for v in bb.body: + if isinstance(v, (X86Instr, BranchInstr)): + print(v.instr.asm_code) + +STUB_NAME = '__native_entry__' +STUB_SIZE = 67 +WITH_OFFS = os.getenv('ASM2ASM_DEBUG_OFFSET', '').lower() in ('1', 'yes', 'true') + +class Assembler: + out : List[str] + subr : Dict[str, int] + code : CodeSection + vals : Dict[str, Union[str, int]] + + def __init__(self): + self.out = [] + self.subr = {} + self.vals = {} + self.code = CodeSection() + + def _get(self, v: str) -> int: + if v not in self.vals: + return self.code.get(v) + elif isinstance(self.vals[v], int): + return self.vals[v] + else: + ret = self.vals[v] = self._eval(self.vals[v]) + return ret + + def _eval(self, v: str) -> int: + return Expression(v).eval(self._get) + + def _emit(self, v: bytes, cmd: str): + align_size = len(v) % 4 + if align_size != 0: + v += int(0).to_bytes(4 - align_size, 'little') + + for i in range(0, len(v), 4): + self.code.emit(v[i:i + 4], '%s %d, %s' % (cmd, len(v[i:i + 4]), repr(v[i:i + 16])[1:])) + + def _limit(self, v: int, a: int, b: int) -> int: + if not (a <= v <= b): + raise SyntaxError('integer constant out of bound [%d, %d): %d' % (a, b, v)) + else: + return v + + def _vfill(self, cmd: str, args: List[str]) -> Tuple[int, int]: + if len(args) == 1: + return self._limit(self._eval(args[0]), 1, 1 << 64), 0 + elif len(args) == 2: + return self._limit(self._eval(args[0]), 1, 1 << 64), self._limit(self._eval(args[1]), 0, 255) + else: + raise SyntaxError(cmd + ' takes 1 ~ 2 arguments') + + def _bytes(self, cmd: str, args: List[str], low: int, high: int, size: int): + if len(args) != 1: + raise SyntaxError(cmd + ' takes exact 1 argument') + else: + self.code.lazy(size, lambda: self._limit(self._eval(args[0]), low, high) & high, '%s %s' % (cmd, args[0])) + + def _comment(self, msg: str): + self.code.blocks[-1].body.append(CommentInstr(msg)) + + def _cmd_nop(self, _: List[str]): + pass + + def _cmd_set(self, args: List[str]): + if len(args) != 2: + raise SyntaxError(".set takes exact 2 argument") + elif not args[0].isidentifier(): + raise SyntaxError(repr(args[0]) + " is not a valid identifier") + else: + key = args[0] + val = args[1] + self.vals[key] = val + self._comment('.set ' + ', '.join(args)) + # special case: clang-generated jump tables are always like '{block}_{table}' + jt = val.find(CLANG_JUMPTABLE_LABLE) + if jt > 0: + tab = self.code.get_jmptab(val[jt:]) + tab.append(self.code.get_block(val[:jt-1])) + + def _cmd_byte(self, args: List[str]): + self._bytes('.byte', args, -0x80, 0xff, 1) + + def _cmd_word(self, args: List[str]): + self._bytes('.word', args, -0x8000, 0xffff, 2) + + def _cmd_long(self, args: List[str]): + self._bytes('.long', args, -0x80000000, 0xffffffff, 4) + + def _cmd_quad(self, args: List[str]): + self._bytes('.quad', args, -0x8000000000000000, 0xffffffffffffffff, 8) + + def _cmd_ascii(self, args: List[str]): + if len(args) != 1: + raise SyntaxError('.ascii takes exact 1 argument') + else: + self._emit(args[0].encode('latin-1'), '.ascii') + + def _cmd_asciz(self, args: List[str]): + if len(args) != 1: + raise SyntaxError('.asciz takes exact 1 argument') + else: + self._emit(args[0].encode('latin-1') + b'\0', '.asciz') + + def _cmd_space(self, args: List[str]): + nb, fv = self._vfill('.space', args) + self._emit(bytes([fv] * nb), '.space') + + def _cmd_p2align(self, args: List[str]): + if len(args) == 1: + self.code.block.body.append(AlignmentInstr(self._eval(args[0]))) + elif len(args) == 2: + self.code.block.body.append(AlignmentInstr(self._eval(args[0]), self._eval(args[1]))) + else: + raise SyntaxError('.p2align takes 1 ~ 2 arguments') + + @functools.cached_property + def _commands(self) -> dict: + return { + '.set' : self._cmd_set, + '.int' : self._cmd_long, + '.long' : self._cmd_long, + '.byte' : self._cmd_byte, + '.quad' : self._cmd_quad, + '.word' : self._cmd_word, + '.hword' : self._cmd_word, + '.short' : self._cmd_word, + '.ascii' : self._cmd_ascii, + '.asciz' : self._cmd_asciz, + '.space' : self._cmd_space, + '.globl' : self._cmd_nop, + '.text' : self._cmd_nop, + '.file' : self._cmd_nop, + '.type' : self._cmd_nop, + '.p2align' : self._cmd_p2align, + '.align' : self._cmd_nop, + '.size' : self._cmd_nop, + '.section' : self._cmd_nop, + '.loh' : self._cmd_nop, + '.data_region' : self._cmd_nop, + '.build_version' : self._cmd_nop, + '.end_data_region' : self._cmd_nop, + '.subsections_via_symbols' : self._cmd_nop, + # linux-gnu + '.xword' :self._cmd_nop, + } + + @staticmethod + def _is_rip_relative(op: Operand) -> bool: + return isinstance(op, Memory) and \ + op.base is not None and \ + op.base.reg == 'rip' and \ + op.index is None and \ + isinstance(op.disp, Reference) + + @staticmethod + def _remove_comments(line: str, *, st: str = 'normal') -> str: + for i, ch in enumerate(line): + if st == 'normal' and ch == '/' : st = 'slcomm' + elif st == 'normal' and ch == '\"' : st = 'string' + # elif st == 'normal' and ch in ('#', ';') : return line[:i] + elif st == 'normal' and ch in (';') : return line[:i] + elif st == 'slcomm' and ch == '/' : return line[:i - 1] + elif st == 'slcomm' : st = 'normal' + elif st == 'string' and ch == '\"' : st = 'normal' + elif st == 'string' and ch == '\\' : st = 'escape' + elif st == 'escape' : st = 'string' + else: + return line + + @staticmethod + def _replace_adrp_line(line: str) -> str: + if 'adrp' in line: + line = line.replace('adrp', 'adr').replace('@PAGE', '') + return line + + @staticmethod + def _replace_adrp(src: List[str]) -> List[str]: + back_label_count = 0 + adrp_label_map = {} + new_src = [] + for line in src: + line = Assembler._remove_comments(line) + line = line.strip() + + if not line: + continue + # is instructions + if line[-1] != ':' and line[0] != '.': + instr = Instruction(line, back_label_count) + if instr.ADRP_label: + back_label_count += 1 + new_src.append(instr.asm_code) + new_src.append(instr.back_label + ':') + if instr.text_label in adrp_label_map: + adrp_label_map[instr.text_label] += [(instr.ADRP_label, instr.ADR_instr, instr.back_label)] + else: + adrp_label_map[instr.text_label] = [(instr.ADRP_label, instr.ADR_instr, instr.back_label)] + else: + new_src.append(line) + else: + new_src.append(line) + + nn_src = [] + + for line in new_src: + if line[-1] == ':': # is label + if line[:-1] in adrp_label_map: + for item in adrp_label_map[line[:-1]]: + nn_src.append(item[0] + ':') # label that adrp will jump to + nn_src.append(item[1]) # adr to get really symbol address + nn_src.append('b ' + item[2]) # jump back to adrp next instruction + nn_src.append(line) + + return nn_src + + def _parse(self, src: List[str]): + # src = self._replace_adrp(o_src) + + for line in src: + line = Assembler._remove_comments(line) + line = line.strip() + + # skip empty lines + if not line: + continue + + # labels, resolve the offset + if line[-1] == ':': + self.code.label(line[:-1]) + continue + + # instructions + if line[0] != '.': + line = self._replace_adrp_line(line) + self.code.instr(Instruction(line, 0)) + continue + + # parse the command + cmd = Command.parse(line) + func = self._commands.get(cmd.cmd) + + # handle the command + if func is not None: + func(cmd.args) + else: + raise SyntaxError('invalid assembly command: ' + cmd.cmd) + + def _reloc(self, rip: int = 0): + for block in self.code.blocks: + for instr in block.body: + rip += self._reloc_one(instr, rip) + + def _reloc_one(self, instr: Instr, rip: int) -> int: + if not isinstance(instr, (X86Instr, BranchInstr)): + return instr.size(rip) + elif instr.instr.need_reloc: + return self._reloc_branch(instr.instr, rip) + else: + return instr.resize(self._reloc_normal(instr.instr, rip)) + + def _reloc_branch(self, instr: Instruction, rip: int) -> int: + label = instr.label_name + if label is None: + raise RuntimeError('cannnot found label name: %s' % instr.asm_code) + if instr.mnemonic == 'adr' and label == 'Ltmp0': + instr.set_label_offset(-4) + else: + instr.set_label_offset(self.code.get(label)- rip - instr.size) + + return instr.size + + def _reloc_normal(self, instr: Instruction, rip: int) -> int: + if instr.need_reloc: + raise SyntaxError('unresolved instruction when relocation: ' + instr.asm_code) + return instr.size + + def _LE_4bytes_IntIntr_2_RawIntr(self): + for block in self.code.blocks: + block.if_all_IntInstr_then_2_RawInstr() + + def _declare(self, protos: PrototypeMap): + if OUTPUT_RAW: + self._declare_body_raw() + else: + self._declare_body() + self._declare_functions(protos) + + def _declare_body(self): + self.out.append('TEXT ·%s(SB), NOSPLIT, $0' % STUB_NAME) + self.out.append('\tNO_LOCAL_POINTERS') + self._LE_4bytes_IntIntr_2_RawIntr() + self._reloc() + + # instruction buffer + pc = 0 + ins = self.code.instrs + + for v in ins: + self.out.append(('// +%d\n' % pc if WITH_OFFS else '') + v.formatted(pc)) + pc += v.size(pc) + + def _declare_body_raw(self): + self._reloc() + + # instruction buffer + pc = 0 + ins = self.code.instrs + + # dump every instruction + for v in ins: + self.out.append(v.raw_formatted(pc)) + pc += v.size(pc) + + def _declare_function(self, name: str, proto: Prototype): + offs = 0 + subr = name[1:] + addr = self.code.get(subr) + self.subr[subr] = addr + size = self.code.pcsp(subr, addr) + m_size = size + 64 + # rsp_sub_size = size + 16 + + if OUTPUT_RAW: + return + + # function header and stack checking + self.out.append('') + # frame size is 16 to store x29 and x30 + # self.out.append('TEXT ·%s(SB), NOSPLIT | NOFRAME, $0-%d' % (name, proto.argspace)) + self.out.append('TEXT ·%s(SB), $%d-%d' % (name, m_size, proto.argspace)) + self.out.append('\tNO_LOCAL_POINTERS') + + # add stack check if needed + # if m_size != 0: + # self.out.append('') + # self.out.append('_entry:') + # self.out.append('\tMOVD 16(g), R16') + # if size > 0: + # if size < (0x1 << 12) - 1: + # self.out.append('\tSUB $%d, RSP, R17' % (m_size)) + # elif size < (0x1 << 16) - 1: + # self.out.append('\tMOVD $%d, R17' % (m_size)) + # self.out.append('\tSUB R17, RSP, R17') + # else: + # raise RuntimeError('too large stack size: %d' % (m_size)) + # self.out.append('\tCMP R16, R17') + # else: + # self.out.append('\tCMP R16, RSP') + # self.out.append('\tBLS _stack_grow') + + # function name + self.out.append('') + self.out.append('%s:' % subr) + + # self.out.append('\tMOVD.W R30, -16(RSP)') + # self.out.append('\tMOVD R29, -8(RSP)') + # self.out.append('\tSUB $8, RSP, R29') + + # intialize all the arguments + for arg in proto.args: + offs += arg.size + op, reg = REG_MAP[arg.creg.reg] + self.out.append('\t%s %s+%d(FP), %s' % (op, arg.name, offs - arg.size, reg)) + + # the function starts at zero + if addr == 0 and proto.retv is None: + raise RuntimeError("UNIMPLEMENT FUNC: %s" % name) + self.out.append('\tJMP ·%s(SB) // %s' % (STUB_NAME, subr)) + + # Go ASM completely ignores the offset of the JMP instruction, + # so we need to use indirect jumps instead for tail-call elimination + elif proto.retv is None: + # raise RuntimeError("UNIMPLEMENT FUNC: %s" % name) + print("%s return void." % name) + # self.out.append('\tLEAQ ·%s+%d(SB), AX // %s' % (STUB_NAME, addr, subr)) + # self.out.append('\tJMP AX') + + # save LR(x30) and Frame Pointer(x29) + + # self.out.append('\tADD $%d, RSP, RSP' % size) + # self.out.append('\tSTP.W (R29, R30), -16(RSP)') + # self.out.append('\tMOVD RSP, R29') + # self.out.append('\tSUB $16, RSP') + self.out.append('\tADD $%d, RSP' % (size + 32)) + self.out.append('\tCALL ·%s+%d(SB) // %s' % (STUB_NAME, addr, subr)) + self.out.append('\tSUB $%d, RSP' % (size + 32)) + # self.out.append('\tADD $16, RSP') + # self.out.append('\tLDP -8(RSP), (R29, R30)') + # self.out.append('\tADD $16, RSP') + # self.out.append('\tLDP.P 16(RSP), (R29, R30)') + # self.out.append('\tSUB $%d, RSP, RSP' % size) + + # Restore LR and Frame Pointer + + # normal functions, call the real function, and return the result + else: + # save LR(x30) and Frame Pointer(x29) + + # We need store return address manual in ARM + # self.out.append('\tSUB $16, RSP') + self.out.append('\tADD $%d, RSP' % (size + 32)) + self.out.append('\tCALL ·%s+%d(SB) // %s' % (STUB_NAME, addr, subr)) + self.out.append('\tSUB $%d, RSP' % (size + 32)) + # self.out.append('\tADD $16, RSP') + # self.out.append('\tSUB $%d, RSP, RSP' % size) + + self.out.append('\t%s, %s+%d(FP)' % (' '.join(REG_MAP[proto.retv.creg.reg]), proto.retv.name, offs)) + + # Restore LR and Frame Pointer + # self.out.append('\tLDP -8(RSP), (R29, R30)') + # self.out.append('\tADD $16, RSP') + + + self.out.append('\tRET') + + # add stack growing if needed + # if m_size != 0: + # self.out.append('') + # self.out.append('_stack_grow:') + # self.out.append('\tMOVD R30, R3') + # self.out.append('\tCALL runtime·morestack_noctxt<>(SB)') + # self.out.append('\tJMP _entry') + + def _declare_functions(self, protos: PrototypeMap): + for name, proto in sorted(protos.items()): + if name[0] == '_': + self._declare_function(name, proto) + else: + raise SyntaxError('function prototype must have a "_" prefix: ' + repr(name)) + + def parse(self, src: List[str], proto: PrototypeMap): + self.code.instr(Instruction('adr x0, .')) + self.code.instr(Instruction('ret')) + + # align 16 bytes + cmd = Command.parse(".p2align 4") + func = self._commands.get(cmd.cmd) + func(cmd.args) + + self._parse(src) + self._declare(proto) + +GOOS = { + 'aix', + 'android', + 'darwin', + 'dragonfly', + 'freebsd', + 'hurd', + 'illumos', + 'js', + 'linux', + 'nacl', + 'netbsd', + 'openbsd', + 'plan9', + 'solaris', + 'windows', + 'zos', +} + +GOARCH = { + '386', + 'amd64', + 'amd64p32', + 'arm', + 'armbe', + 'arm64', + 'arm64be', + 'ppc64', + 'ppc64le', + 'mips', + 'mipsle', + 'mips64', + 'mips64le', + 'mips64p32', + 'mips64p32le', + 'ppc', + 'riscv', + 'riscv64', + 's390', + 's390x', + 'sparc', + 'sparc64', + 'wasm', +} + +def make_subr_filename(name: str) -> str: + name = os.path.basename(name) + base = os.path.splitext(name)[0].rsplit('_', 2) + + # construct the new name + if base[-1] in GOOS: + return '%s_subr_%s.go' % ('_'.join(base[:-1]), base[-1]) + elif base[-1] not in GOARCH: + return '%s_subr.go' % '_'.join(base) + elif len(base) > 2 and base[-2] in GOOS: + return '%s_subr_%s_%s.go' % ('_'.join(base[:-2]), base[-2], base[-1]) + else: + return '%s_subr_%s.go' % ('_'.join(base[:-1]), base[-1]) + +def parse_args(): + parser = argparse.ArgumentParser(description='Convert llvm asm to golang asm.') + parser.add_argument('proto_file', type=str, help = 'The go file that declares go functions') + parser.add_argument('asm_file', type=str, nargs='+', help = 'The llvm assembly file') + parser.add_argument('-r', default=False, action='store_true', help = 'Ture: output as raw; default is False') + return parser.parse_args() + +def main(): + src = [] + asm = Assembler() + args = parse_args() + + # check if optional flag is enabled + global OUTPUT_RAW + OUTPUT_RAW = False + if args.r: + OUTPUT_RAW = True + + proto_name = os.path.splitext(args.proto_file)[0] + + # parse the prototype + with open(proto_name + '.go', 'r', newline = None) as fp: + pkg, proto = PrototypeMap.parse(fp.read()) + + # read all the sources, and combine them together + for fn in args.asm_file: + with open(fn, 'r', newline = None) as fp: + src.extend(fp.read().splitlines()) + + # convert the original sources + if OUTPUT_RAW: + asm.out.append('// +build arm64') + asm.out.append('// Code generated by asm2asm, DO NOT EDIT.') + asm.out.append('') + asm.out.append('package %s' % pkg) + asm.out.append('') + ## native text + asm.out.append('var Text%s = []byte{' % STUB_NAME) + else: + asm.out.append('// +build !noasm !appengine') + asm.out.append('// Code generated by asm2asm, DO NOT EDIT.') + asm.out.append('') + asm.out.append('#include "go_asm.h"') + asm.out.append('#include "funcdata.h"') + asm.out.append('#include "textflag.h"') + asm.out.append('') + + asm.parse(src, proto) + + if OUTPUT_RAW: + asrc = proto_name[:proto_name.rfind('_')] + '_text_arm.go' + else: + asrc = proto_name + '.s' + + # save the converted result + with open(asrc, 'w') as fp: + for line in asm.out: + print(line, file = fp) + if OUTPUT_RAW: + print('}', file = fp) + + # calculate the subroutine stub file name + subr = make_subr_filename(args.proto_file) + subr = os.path.join(os.path.dirname(args.proto_file), subr) + + # save the compiled code stub + with open(subr, 'w') as fp: + print('// +build !noasm !appengine', file = fp) + print('// Code generated by asm2asm, DO NOT EDIT.', file = fp) + print(file = fp) + print('package %s' % pkg, file = fp) + + # also save the actual function addresses if any + if not asm.subr: + return + + if OUTPUT_RAW: + print(file = fp) + print('import (\n\t`github.com/bytedance/sonic/loader`\n)', file = fp) + + # dump every entry for all functions + print(file = fp) + print('const (', file = fp) + for name in asm.code.funcs.keys(): + addr = asm.code.get(name) + if addr is not None: + print(f' _entry_{name} = %d' % addr, file = fp) + print(')', file = fp) + + # dump max stack depth for all functions + print(file = fp) + print('const (', file = fp) + for name in asm.code.funcs.keys(): + print(' _stack_%s = %d' % (name, asm.code.stacksize(name)), file = fp) + print(')', file = fp) + + # dump every text size for all functions + print(file = fp) + print('const (', file = fp) + for name, pcsp in asm.code.funcs.items(): + if pcsp is not None: + # print(f'before {name} optimize {pcsp}') + pcsp.optimize() + # print(f'after {name} optimize {pcsp}') + print(f' _size_{name} = %d' % (pcsp.maxpc - pcsp.entry), file = fp) + print(')', file = fp) + + # dump every pcsp for all functions + print(file = fp) + print('var (', file = fp) + for name, pcsp in asm.code.funcs.items(): + if pcsp is not None: + print(f' _pcsp_{name} = %s' % pcsp, file = fp) + print(')', file = fp) + + # insert native entry info + print(file = fp) + print('var Funcs = []loader.CFunc{', file = fp) + print(' {"%s", 0, %d, 0, nil},' % (STUB_NAME, STUB_SIZE), file = fp) + # dump every native function info for all functions + for name in asm.code.funcs.keys(): + print(' {"%s", _entry_%s, _size_%s, _stack_%s, _pcsp_%s},' % (name, name, name, name, name), file = fp) + print('}', file = fp) + + else: + # native entry for entry function + print(file = fp) + print('//go:nosplit', file = fp) + print('//go:noescape', file = fp) + print('//goland:noinspection ALL', file = fp) + print('func %s() uintptr' % STUB_NAME, file = fp) + + # dump exported function entry for exported functions + print(file = fp) + print('var (', file = fp) + mlen = max(len(s) for s in asm.subr) + for name, entry in asm.subr.items(): + print(' _subr_%s uintptr = %s() + %d' % (name.ljust(mlen, ' '), STUB_NAME, entry), file = fp) + print(')', file = fp) + + # dump max stack depth for exported functions + print(file = fp) + print('const (', file = fp) + for name in asm.subr.keys(): + print(' _stack_%s = %d' % (name, asm.code.stacksize(name)), file = fp) + print(')', file = fp) + + # assign subroutine offsets to '_' to mute the "unused" warnings + print(file = fp) + print('var (', file = fp) + for name in asm.subr: + print(' _ = _subr_%s' % name, file = fp) + print(')', file = fp) + + # dump every constant + print(file = fp) + print('const (', file = fp) + for name in asm.subr: + print(' _ = _stack_%s' % name, file = fp) + else: + print(')', file = fp) + +if __name__ == '__main__': + main() diff --git a/tools/asm2arm/requirements.txt b/tools/asm2arm/requirements.txt new file mode 100644 index 000000000..6c46c31a1 --- /dev/null +++ b/tools/asm2arm/requirements.txt @@ -0,0 +1,2 @@ +git+https://github.com/Maratyszcza/PeachPy +git+https://github.com/GrammaTech/mc-asm